1 /******************************************************************************
5 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
24 * Contact Information:
25 * Intel Linux Wireless <ilw@linux.intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *****************************************************************************/
28 #include <linux/ieee80211.h>
29 #include <linux/export.h>
30 #include <net/mac80211.h>
35 il_clear_traffic_stats(struct il_priv
*il
)
37 memset(&il
->tx_stats
, 0, sizeof(struct traffic_stats
));
38 memset(&il
->rx_stats
, 0, sizeof(struct traffic_stats
));
42 * il_update_stats function record all the MGMT, CTRL and DATA pkt for
43 * both TX and Rx . Use debugfs to display the rx/rx_stats
46 il_update_stats(struct il_priv
*il
, bool is_tx
, __le16 fc
, u16 len
)
48 struct traffic_stats
*stats
;
51 stats
= &il
->tx_stats
;
53 stats
= &il
->rx_stats
;
55 if (ieee80211_is_mgmt(fc
)) {
56 switch (fc
& cpu_to_le16(IEEE80211_FCTL_STYPE
)) {
57 case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ
):
58 stats
->mgmt
[MANAGEMENT_ASSOC_REQ
]++;
60 case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP
):
61 stats
->mgmt
[MANAGEMENT_ASSOC_RESP
]++;
63 case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ
):
64 stats
->mgmt
[MANAGEMENT_REASSOC_REQ
]++;
66 case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP
):
67 stats
->mgmt
[MANAGEMENT_REASSOC_RESP
]++;
69 case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
):
70 stats
->mgmt
[MANAGEMENT_PROBE_REQ
]++;
72 case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP
):
73 stats
->mgmt
[MANAGEMENT_PROBE_RESP
]++;
75 case cpu_to_le16(IEEE80211_STYPE_BEACON
):
76 stats
->mgmt
[MANAGEMENT_BEACON
]++;
78 case cpu_to_le16(IEEE80211_STYPE_ATIM
):
79 stats
->mgmt
[MANAGEMENT_ATIM
]++;
81 case cpu_to_le16(IEEE80211_STYPE_DISASSOC
):
82 stats
->mgmt
[MANAGEMENT_DISASSOC
]++;
84 case cpu_to_le16(IEEE80211_STYPE_AUTH
):
85 stats
->mgmt
[MANAGEMENT_AUTH
]++;
87 case cpu_to_le16(IEEE80211_STYPE_DEAUTH
):
88 stats
->mgmt
[MANAGEMENT_DEAUTH
]++;
90 case cpu_to_le16(IEEE80211_STYPE_ACTION
):
91 stats
->mgmt
[MANAGEMENT_ACTION
]++;
94 } else if (ieee80211_is_ctl(fc
)) {
95 switch (fc
& cpu_to_le16(IEEE80211_FCTL_STYPE
)) {
96 case cpu_to_le16(IEEE80211_STYPE_BACK_REQ
):
97 stats
->ctrl
[CONTROL_BACK_REQ
]++;
99 case cpu_to_le16(IEEE80211_STYPE_BACK
):
100 stats
->ctrl
[CONTROL_BACK
]++;
102 case cpu_to_le16(IEEE80211_STYPE_PSPOLL
):
103 stats
->ctrl
[CONTROL_PSPOLL
]++;
105 case cpu_to_le16(IEEE80211_STYPE_RTS
):
106 stats
->ctrl
[CONTROL_RTS
]++;
108 case cpu_to_le16(IEEE80211_STYPE_CTS
):
109 stats
->ctrl
[CONTROL_CTS
]++;
111 case cpu_to_le16(IEEE80211_STYPE_ACK
):
112 stats
->ctrl
[CONTROL_ACK
]++;
114 case cpu_to_le16(IEEE80211_STYPE_CFEND
):
115 stats
->ctrl
[CONTROL_CFEND
]++;
117 case cpu_to_le16(IEEE80211_STYPE_CFENDACK
):
118 stats
->ctrl
[CONTROL_CFENDACK
]++;
124 stats
->data_bytes
+= len
;
127 EXPORT_SYMBOL(il_update_stats
);
129 /* create and remove of files */
130 #define DEBUGFS_ADD_FILE(name, parent, mode) do { \
131 if (!debugfs_create_file(#name, mode, parent, il, \
132 &il_dbgfs_##name##_ops)) \
136 #define DEBUGFS_ADD_BOOL(name, parent, ptr) do { \
137 struct dentry *__tmp; \
138 __tmp = debugfs_create_bool(#name, S_IWUSR | S_IRUSR, \
140 if (IS_ERR(__tmp) || !__tmp) \
144 #define DEBUGFS_ADD_X32(name, parent, ptr) do { \
145 struct dentry *__tmp; \
146 __tmp = debugfs_create_x32(#name, S_IWUSR | S_IRUSR, \
148 if (IS_ERR(__tmp) || !__tmp) \
153 #define DEBUGFS_READ_FUNC(name) \
154 static ssize_t il_dbgfs_##name##_read(struct file *file, \
155 char __user *user_buf, \
156 size_t count, loff_t *ppos);
158 #define DEBUGFS_WRITE_FUNC(name) \
159 static ssize_t il_dbgfs_##name##_write(struct file *file, \
160 const char __user *user_buf, \
161 size_t count, loff_t *ppos);
164 il_dbgfs_open_file_generic(struct inode
*inode
, struct file
*file
)
166 file
->private_data
= inode
->i_private
;
170 #define DEBUGFS_READ_FILE_OPS(name) \
171 DEBUGFS_READ_FUNC(name); \
172 static const struct file_operations il_dbgfs_##name##_ops = { \
173 .read = il_dbgfs_##name##_read, \
174 .open = il_dbgfs_open_file_generic, \
175 .llseek = generic_file_llseek, \
178 #define DEBUGFS_WRITE_FILE_OPS(name) \
179 DEBUGFS_WRITE_FUNC(name); \
180 static const struct file_operations il_dbgfs_##name##_ops = { \
181 .write = il_dbgfs_##name##_write, \
182 .open = il_dbgfs_open_file_generic, \
183 .llseek = generic_file_llseek, \
186 #define DEBUGFS_READ_WRITE_FILE_OPS(name) \
187 DEBUGFS_READ_FUNC(name); \
188 DEBUGFS_WRITE_FUNC(name); \
189 static const struct file_operations il_dbgfs_##name##_ops = { \
190 .write = il_dbgfs_##name##_write, \
191 .read = il_dbgfs_##name##_read, \
192 .open = il_dbgfs_open_file_generic, \
193 .llseek = generic_file_llseek, \
197 il_get_mgmt_string(int cmd
)
200 IL_CMD(MANAGEMENT_ASSOC_REQ
);
201 IL_CMD(MANAGEMENT_ASSOC_RESP
);
202 IL_CMD(MANAGEMENT_REASSOC_REQ
);
203 IL_CMD(MANAGEMENT_REASSOC_RESP
);
204 IL_CMD(MANAGEMENT_PROBE_REQ
);
205 IL_CMD(MANAGEMENT_PROBE_RESP
);
206 IL_CMD(MANAGEMENT_BEACON
);
207 IL_CMD(MANAGEMENT_ATIM
);
208 IL_CMD(MANAGEMENT_DISASSOC
);
209 IL_CMD(MANAGEMENT_AUTH
);
210 IL_CMD(MANAGEMENT_DEAUTH
);
211 IL_CMD(MANAGEMENT_ACTION
);
219 il_get_ctrl_string(int cmd
)
222 IL_CMD(CONTROL_BACK_REQ
);
223 IL_CMD(CONTROL_BACK
);
224 IL_CMD(CONTROL_PSPOLL
);
228 IL_CMD(CONTROL_CFEND
);
229 IL_CMD(CONTROL_CFENDACK
);
237 il_dbgfs_tx_stats_read(struct file
*file
, char __user
*user_buf
, size_t count
,
241 struct il_priv
*il
= file
->private_data
;
248 100 + sizeof(char) * 50 * (MANAGEMENT_MAX
+ CONTROL_MAX
);
249 buf
= kzalloc(bufsz
, GFP_KERNEL
);
252 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Management:\n");
253 for (cnt
= 0; cnt
< MANAGEMENT_MAX
; cnt
++) {
255 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
256 il_get_mgmt_string(cnt
), il
->tx_stats
.mgmt
[cnt
]);
258 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Control\n");
259 for (cnt
= 0; cnt
< CONTROL_MAX
; cnt
++) {
261 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
262 il_get_ctrl_string(cnt
), il
->tx_stats
.ctrl
[cnt
]);
264 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Data:\n");
266 scnprintf(buf
+ pos
, bufsz
- pos
, "\tcnt: %u\n",
267 il
->tx_stats
.data_cnt
);
269 scnprintf(buf
+ pos
, bufsz
- pos
, "\tbytes: %llu\n",
270 il
->tx_stats
.data_bytes
);
271 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
277 il_dbgfs_clear_traffic_stats_write(struct file
*file
,
278 const char __user
*user_buf
, size_t count
,
281 struct il_priv
*il
= file
->private_data
;
286 memset(buf
, 0, sizeof(buf
));
287 buf_size
= min(count
, sizeof(buf
) - 1);
288 if (copy_from_user(buf
, user_buf
, buf_size
))
290 if (sscanf(buf
, "%x", &clear_flag
) != 1)
292 il_clear_traffic_stats(il
);
298 il_dbgfs_rx_stats_read(struct file
*file
, char __user
*user_buf
, size_t count
,
302 struct il_priv
*il
= file
->private_data
;
308 100 + sizeof(char) * 50 * (MANAGEMENT_MAX
+ CONTROL_MAX
);
309 buf
= kzalloc(bufsz
, GFP_KERNEL
);
313 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Management:\n");
314 for (cnt
= 0; cnt
< MANAGEMENT_MAX
; cnt
++) {
316 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
317 il_get_mgmt_string(cnt
), il
->rx_stats
.mgmt
[cnt
]);
319 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Control:\n");
320 for (cnt
= 0; cnt
< CONTROL_MAX
; cnt
++) {
322 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
323 il_get_ctrl_string(cnt
), il
->rx_stats
.ctrl
[cnt
]);
325 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Data:\n");
327 scnprintf(buf
+ pos
, bufsz
- pos
, "\tcnt: %u\n",
328 il
->rx_stats
.data_cnt
);
330 scnprintf(buf
+ pos
, bufsz
- pos
, "\tbytes: %llu\n",
331 il
->rx_stats
.data_bytes
);
333 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
338 #define BYTE1_MASK 0x000000ff;
339 #define BYTE2_MASK 0x0000ffff;
340 #define BYTE3_MASK 0x00ffffff;
342 il_dbgfs_sram_read(struct file
*file
, char __user
*user_buf
, size_t count
,
350 struct il_priv
*il
= file
->private_data
;
353 /* default is to dump the entire data segment */
354 if (!il
->dbgfs_sram_offset
&& !il
->dbgfs_sram_len
) {
355 il
->dbgfs_sram_offset
= 0x800000;
356 if (il
->ucode_type
== UCODE_INIT
)
357 il
->dbgfs_sram_len
= il
->ucode_init_data
.len
;
359 il
->dbgfs_sram_len
= il
->ucode_data
.len
;
361 bufsz
= 30 + il
->dbgfs_sram_len
* sizeof(char) * 10;
362 buf
= kmalloc(bufsz
, GFP_KERNEL
);
366 scnprintf(buf
+ pos
, bufsz
- pos
, "sram_len: 0x%x\n",
369 scnprintf(buf
+ pos
, bufsz
- pos
, "sram_offset: 0x%x\n",
370 il
->dbgfs_sram_offset
);
371 for (i
= il
->dbgfs_sram_len
; i
> 0; i
-= 4) {
374 il
->dbgfs_sram_offset
+
375 il
->dbgfs_sram_len
- i
);
390 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
391 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "0x%08x ", val
);
393 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
395 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
401 il_dbgfs_sram_write(struct file
*file
, const char __user
*user_buf
,
402 size_t count
, loff_t
*ppos
)
404 struct il_priv
*il
= file
->private_data
;
409 memset(buf
, 0, sizeof(buf
));
410 buf_size
= min(count
, sizeof(buf
) - 1);
411 if (copy_from_user(buf
, user_buf
, buf_size
))
414 if (sscanf(buf
, "%x,%x", &offset
, &len
) == 2) {
415 il
->dbgfs_sram_offset
= offset
;
416 il
->dbgfs_sram_len
= len
;
418 il
->dbgfs_sram_offset
= 0;
419 il
->dbgfs_sram_len
= 0;
426 il_dbgfs_stations_read(struct file
*file
, char __user
*user_buf
, size_t count
,
429 struct il_priv
*il
= file
->private_data
;
430 struct il_station_entry
*station
;
431 int max_sta
= il
->hw_params
.max_stations
;
435 /* Add 30 for initial string */
436 const size_t bufsz
= 30 + sizeof(char) * 500 * (il
->num_stations
);
438 buf
= kmalloc(bufsz
, GFP_KERNEL
);
443 scnprintf(buf
+ pos
, bufsz
- pos
, "num of stations: %d\n\n",
446 for (i
= 0; i
< max_sta
; i
++) {
447 station
= &il
->stations
[i
];
451 scnprintf(buf
+ pos
, bufsz
- pos
,
452 "station %d - addr: %pM, flags: %#x\n", i
,
453 station
->sta
.sta
.addr
,
454 station
->sta
.station_flags_msk
);
456 scnprintf(buf
+ pos
, bufsz
- pos
,
457 "TID\tseq_num\ttxq_id\tframes\ttfds\t");
459 scnprintf(buf
+ pos
, bufsz
- pos
,
460 "start_idx\tbitmap\t\t\trate_n_flags\n");
462 for (j
= 0; j
< MAX_TID_COUNT
; j
++) {
464 scnprintf(buf
+ pos
, bufsz
- pos
,
465 "%d:\t%#x\t%#x\t%u\t%u\t%u\t\t%#.16llx\t%#x",
466 j
, station
->tid
[j
].seq_number
,
467 station
->tid
[j
].agg
.txq_id
,
468 station
->tid
[j
].agg
.frame_count
,
469 station
->tid
[j
].tfds_in_queue
,
470 station
->tid
[j
].agg
.start_idx
,
471 station
->tid
[j
].agg
.bitmap
,
472 station
->tid
[j
].agg
.rate_n_flags
);
474 if (station
->tid
[j
].agg
.wait_for_ba
)
476 scnprintf(buf
+ pos
, bufsz
- pos
,
478 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
481 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
484 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
490 il_dbgfs_nvm_read(struct file
*file
, char __user
*user_buf
, size_t count
,
494 struct il_priv
*il
= file
->private_data
;
495 int pos
= 0, ofs
= 0, buf_size
= 0;
499 size_t eeprom_len
= il
->cfg
->eeprom_size
;
500 buf_size
= 4 * eeprom_len
+ 256;
502 if (eeprom_len
% 16) {
503 IL_ERR("NVM size is not multiple of 16.\n");
509 IL_ERR("Invalid EEPROM memory\n");
513 /* 4 characters for byte 0xYY */
514 buf
= kzalloc(buf_size
, GFP_KERNEL
);
516 IL_ERR("Can not allocate Buffer\n");
519 eeprom_ver
= il_eeprom_query16(il
, EEPROM_VERSION
);
521 scnprintf(buf
+ pos
, buf_size
- pos
, "EEPROM " "version: 0x%x\n",
523 for (ofs
= 0; ofs
< eeprom_len
; ofs
+= 16) {
524 pos
+= scnprintf(buf
+ pos
, buf_size
- pos
, "0x%.4x ", ofs
);
525 hex_dump_to_buffer(ptr
+ ofs
, 16, 16, 2, buf
+ pos
,
527 pos
+= strlen(buf
+ pos
);
528 if (buf_size
- pos
> 0)
532 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
538 il_dbgfs_channels_read(struct file
*file
, char __user
*user_buf
, size_t count
,
541 struct il_priv
*il
= file
->private_data
;
542 struct ieee80211_channel
*channels
= NULL
;
543 const struct ieee80211_supported_band
*supp_band
= NULL
;
544 int pos
= 0, i
, bufsz
= PAGE_SIZE
;
548 if (!test_bit(S_GEO_CONFIGURED
, &il
->status
))
551 buf
= kzalloc(bufsz
, GFP_KERNEL
);
553 IL_ERR("Can not allocate Buffer\n");
557 supp_band
= il_get_hw_mode(il
, IEEE80211_BAND_2GHZ
);
559 channels
= supp_band
->channels
;
562 scnprintf(buf
+ pos
, bufsz
- pos
,
563 "Displaying %d channels in 2.4GHz band 802.11bg):\n",
564 supp_band
->n_channels
);
566 for (i
= 0; i
< supp_band
->n_channels
; i
++)
568 scnprintf(buf
+ pos
, bufsz
- pos
,
569 "%d: %ddBm: BSS%s%s, %s.\n",
570 channels
[i
].hw_value
,
571 channels
[i
].max_power
,
573 flags
& IEEE80211_CHAN_RADAR
?
574 " (IEEE 802.11h required)" : "",
576 flags
& IEEE80211_CHAN_NO_IBSS
) ||
578 flags
& IEEE80211_CHAN_RADAR
)) ? "" :
581 flags
& IEEE80211_CHAN_PASSIVE_SCAN
?
582 "passive only" : "active/passive");
584 supp_band
= il_get_hw_mode(il
, IEEE80211_BAND_5GHZ
);
586 channels
= supp_band
->channels
;
589 scnprintf(buf
+ pos
, bufsz
- pos
,
590 "Displaying %d channels in 5.2GHz band (802.11a)\n",
591 supp_band
->n_channels
);
593 for (i
= 0; i
< supp_band
->n_channels
; i
++)
595 scnprintf(buf
+ pos
, bufsz
- pos
,
596 "%d: %ddBm: BSS%s%s, %s.\n",
597 channels
[i
].hw_value
,
598 channels
[i
].max_power
,
600 flags
& IEEE80211_CHAN_RADAR
?
601 " (IEEE 802.11h required)" : "",
603 flags
& IEEE80211_CHAN_NO_IBSS
) ||
605 flags
& IEEE80211_CHAN_RADAR
)) ? "" :
608 flags
& IEEE80211_CHAN_PASSIVE_SCAN
?
609 "passive only" : "active/passive");
611 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
617 il_dbgfs_status_read(struct file
*file
, char __user
*user_buf
, size_t count
,
621 struct il_priv
*il
= file
->private_data
;
624 const size_t bufsz
= sizeof(buf
);
627 scnprintf(buf
+ pos
, bufsz
- pos
, "S_HCMD_ACTIVE:\t %d\n",
628 test_bit(S_HCMD_ACTIVE
, &il
->status
));
630 scnprintf(buf
+ pos
, bufsz
- pos
, "S_INT_ENABLED:\t %d\n",
631 test_bit(S_INT_ENABLED
, &il
->status
));
633 scnprintf(buf
+ pos
, bufsz
- pos
, "S_RFKILL:\t %d\n",
634 test_bit(S_RFKILL
, &il
->status
));
636 scnprintf(buf
+ pos
, bufsz
- pos
, "S_CT_KILL:\t\t %d\n",
637 test_bit(S_CT_KILL
, &il
->status
));
639 scnprintf(buf
+ pos
, bufsz
- pos
, "S_INIT:\t\t %d\n",
640 test_bit(S_INIT
, &il
->status
));
642 scnprintf(buf
+ pos
, bufsz
- pos
, "S_ALIVE:\t\t %d\n",
643 test_bit(S_ALIVE
, &il
->status
));
645 scnprintf(buf
+ pos
, bufsz
- pos
, "S_READY:\t\t %d\n",
646 test_bit(S_READY
, &il
->status
));
648 scnprintf(buf
+ pos
, bufsz
- pos
, "S_TEMPERATURE:\t %d\n",
649 test_bit(S_TEMPERATURE
, &il
->status
));
651 scnprintf(buf
+ pos
, bufsz
- pos
, "S_GEO_CONFIGURED:\t %d\n",
652 test_bit(S_GEO_CONFIGURED
, &il
->status
));
654 scnprintf(buf
+ pos
, bufsz
- pos
, "S_EXIT_PENDING:\t %d\n",
655 test_bit(S_EXIT_PENDING
, &il
->status
));
657 scnprintf(buf
+ pos
, bufsz
- pos
, "S_STATS:\t %d\n",
658 test_bit(S_STATS
, &il
->status
));
660 scnprintf(buf
+ pos
, bufsz
- pos
, "S_SCANNING:\t %d\n",
661 test_bit(S_SCANNING
, &il
->status
));
663 scnprintf(buf
+ pos
, bufsz
- pos
, "S_SCAN_ABORTING:\t %d\n",
664 test_bit(S_SCAN_ABORTING
, &il
->status
));
666 scnprintf(buf
+ pos
, bufsz
- pos
, "S_SCAN_HW:\t\t %d\n",
667 test_bit(S_SCAN_HW
, &il
->status
));
669 scnprintf(buf
+ pos
, bufsz
- pos
, "S_POWER_PMI:\t %d\n",
670 test_bit(S_POWER_PMI
, &il
->status
));
672 scnprintf(buf
+ pos
, bufsz
- pos
, "S_FW_ERROR:\t %d\n",
673 test_bit(S_FW_ERROR
, &il
->status
));
674 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
678 il_dbgfs_interrupt_read(struct file
*file
, char __user
*user_buf
, size_t count
,
682 struct il_priv
*il
= file
->private_data
;
686 int bufsz
= 24 * 64; /* 24 items * 64 char per item */
689 buf
= kzalloc(bufsz
, GFP_KERNEL
);
691 IL_ERR("Can not allocate Buffer\n");
696 scnprintf(buf
+ pos
, bufsz
- pos
, "Interrupt Statistics Report:\n");
699 scnprintf(buf
+ pos
, bufsz
- pos
, "HW Error:\t\t\t %u\n",
702 scnprintf(buf
+ pos
, bufsz
- pos
, "SW Error:\t\t\t %u\n",
704 if (il
->isr_stats
.sw
|| il
->isr_stats
.hw
) {
706 scnprintf(buf
+ pos
, bufsz
- pos
,
707 "\tLast Restarting Code: 0x%X\n",
708 il
->isr_stats
.err_code
);
710 #ifdef CONFIG_IWLEGACY_DEBUG
712 scnprintf(buf
+ pos
, bufsz
- pos
, "Frame transmitted:\t\t %u\n",
715 scnprintf(buf
+ pos
, bufsz
- pos
, "Alive interrupt:\t\t %u\n",
716 il
->isr_stats
.alive
);
719 scnprintf(buf
+ pos
, bufsz
- pos
,
720 "HW RF KILL switch toggled:\t %u\n",
721 il
->isr_stats
.rfkill
);
724 scnprintf(buf
+ pos
, bufsz
- pos
, "CT KILL:\t\t\t %u\n",
725 il
->isr_stats
.ctkill
);
728 scnprintf(buf
+ pos
, bufsz
- pos
, "Wakeup Interrupt:\t\t %u\n",
729 il
->isr_stats
.wakeup
);
732 scnprintf(buf
+ pos
, bufsz
- pos
, "Rx command responses:\t\t %u\n",
734 for (cnt
= 0; cnt
< IL_CN_MAX
; cnt
++) {
735 if (il
->isr_stats
.handlers
[cnt
] > 0)
737 scnprintf(buf
+ pos
, bufsz
- pos
,
738 "\tRx handler[%36s]:\t\t %u\n",
739 il_get_cmd_string(cnt
),
740 il
->isr_stats
.handlers
[cnt
]);
744 scnprintf(buf
+ pos
, bufsz
- pos
, "Tx/FH interrupt:\t\t %u\n",
748 scnprintf(buf
+ pos
, bufsz
- pos
, "Unexpected INTA:\t\t %u\n",
749 il
->isr_stats
.unhandled
);
751 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
757 il_dbgfs_interrupt_write(struct file
*file
, const char __user
*user_buf
,
758 size_t count
, loff_t
*ppos
)
760 struct il_priv
*il
= file
->private_data
;
765 memset(buf
, 0, sizeof(buf
));
766 buf_size
= min(count
, sizeof(buf
) - 1);
767 if (copy_from_user(buf
, user_buf
, buf_size
))
769 if (sscanf(buf
, "%x", &reset_flag
) != 1)
772 il_clear_isr_stats(il
);
778 il_dbgfs_qos_read(struct file
*file
, char __user
*user_buf
, size_t count
,
781 struct il_priv
*il
= file
->private_data
;
784 const size_t bufsz
= sizeof(buf
);
786 for (i
= 0; i
< AC_NUM
; i
++) {
788 scnprintf(buf
+ pos
, bufsz
- pos
,
789 "\tcw_min\tcw_max\taifsn\ttxop\n");
791 scnprintf(buf
+ pos
, bufsz
- pos
,
792 "AC[%d]\t%u\t%u\t%u\t%u\n", i
,
793 il
->qos_data
.def_qos_parm
.ac
[i
].cw_min
,
794 il
->qos_data
.def_qos_parm
.ac
[i
].cw_max
,
795 il
->qos_data
.def_qos_parm
.ac
[i
].aifsn
,
796 il
->qos_data
.def_qos_parm
.ac
[i
].edca_txop
);
799 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
803 il_dbgfs_disable_ht40_write(struct file
*file
, const char __user
*user_buf
,
804 size_t count
, loff_t
*ppos
)
806 struct il_priv
*il
= file
->private_data
;
811 memset(buf
, 0, sizeof(buf
));
812 buf_size
= min(count
, sizeof(buf
) - 1);
813 if (copy_from_user(buf
, user_buf
, buf_size
))
815 if (sscanf(buf
, "%d", &ht40
) != 1)
817 if (!il_is_any_associated(il
))
818 il
->disable_ht40
= ht40
? true : false;
820 IL_ERR("Sta associated with AP - "
821 "Change to 40MHz channel support is not allowed\n");
829 il_dbgfs_disable_ht40_read(struct file
*file
, char __user
*user_buf
,
830 size_t count
, loff_t
*ppos
)
832 struct il_priv
*il
= file
->private_data
;
835 const size_t bufsz
= sizeof(buf
);
838 scnprintf(buf
+ pos
, bufsz
- pos
, "11n 40MHz Mode: %s\n",
839 il
->disable_ht40
? "Disabled" : "Enabled");
840 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
843 DEBUGFS_READ_WRITE_FILE_OPS(sram
);
844 DEBUGFS_READ_FILE_OPS(nvm
);
845 DEBUGFS_READ_FILE_OPS(stations
);
846 DEBUGFS_READ_FILE_OPS(channels
);
847 DEBUGFS_READ_FILE_OPS(status
);
848 DEBUGFS_READ_WRITE_FILE_OPS(interrupt
);
849 DEBUGFS_READ_FILE_OPS(qos
);
850 DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40
);
853 il_dbgfs_tx_queue_read(struct file
*file
, char __user
*user_buf
, size_t count
,
857 struct il_priv
*il
= file
->private_data
;
858 struct il_tx_queue
*txq
;
865 sizeof(char) * 64 * il
->cfg
->num_of_queues
;
868 IL_ERR("txq not ready\n");
871 buf
= kzalloc(bufsz
, GFP_KERNEL
);
875 for (cnt
= 0; cnt
< il
->hw_params
.max_txq_num
; cnt
++) {
879 scnprintf(buf
+ pos
, bufsz
- pos
,
880 "hwq %.2d: read=%u write=%u stop=%d"
881 " swq_id=%#.2x (ac %d/hwq %d)\n", cnt
,
882 q
->read_ptr
, q
->write_ptr
,
883 !!test_bit(cnt
, il
->queue_stopped
),
884 txq
->swq_id
, txq
->swq_id
& 3,
885 (txq
->swq_id
>> 2) & 0x1f);
888 /* for the ACs, display the stop count too */
890 scnprintf(buf
+ pos
, bufsz
- pos
,
892 atomic_read(&il
->queue_stop_count
[cnt
]));
894 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
900 il_dbgfs_rx_queue_read(struct file
*file
, char __user
*user_buf
, size_t count
,
904 struct il_priv
*il
= file
->private_data
;
905 struct il_rx_queue
*rxq
= &il
->rxq
;
908 const size_t bufsz
= sizeof(buf
);
910 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "read: %u\n", rxq
->read
);
911 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "write: %u\n", rxq
->write
);
913 scnprintf(buf
+ pos
, bufsz
- pos
, "free_count: %u\n",
917 scnprintf(buf
+ pos
, bufsz
- pos
, "closed_rb_num: %u\n",
918 le16_to_cpu(rxq
->rb_stts
->
919 closed_rb_num
) & 0x0FFF);
922 scnprintf(buf
+ pos
, bufsz
- pos
,
923 "closed_rb_num: Not Allocated\n");
925 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
929 il_dbgfs_ucode_rx_stats_read(struct file
*file
, char __user
*user_buf
,
930 size_t count
, loff_t
*ppos
)
932 struct il_priv
*il
= file
->private_data
;
934 return il
->debugfs_ops
->rx_stats_read(file
, user_buf
, count
, ppos
);
938 il_dbgfs_ucode_tx_stats_read(struct file
*file
, char __user
*user_buf
,
939 size_t count
, loff_t
*ppos
)
941 struct il_priv
*il
= file
->private_data
;
943 return il
->debugfs_ops
->tx_stats_read(file
, user_buf
, count
, ppos
);
947 il_dbgfs_ucode_general_stats_read(struct file
*file
, char __user
*user_buf
,
948 size_t count
, loff_t
*ppos
)
950 struct il_priv
*il
= file
->private_data
;
952 return il
->debugfs_ops
->general_stats_read(file
, user_buf
, count
, ppos
);
956 il_dbgfs_sensitivity_read(struct file
*file
, char __user
*user_buf
,
957 size_t count
, loff_t
*ppos
)
960 struct il_priv
*il
= file
->private_data
;
964 int bufsz
= sizeof(struct il_sensitivity_data
) * 4 + 100;
966 struct il_sensitivity_data
*data
;
968 data
= &il
->sensitivity_data
;
969 buf
= kzalloc(bufsz
, GFP_KERNEL
);
971 IL_ERR("Can not allocate Buffer\n");
976 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm:\t\t\t %u\n",
977 data
->auto_corr_ofdm
);
979 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm_mrc:\t\t %u\n",
980 data
->auto_corr_ofdm_mrc
);
982 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm_x1:\t\t %u\n",
983 data
->auto_corr_ofdm_x1
);
985 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm_mrc_x1:\t\t %u\n",
986 data
->auto_corr_ofdm_mrc_x1
);
988 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_cck:\t\t\t %u\n",
989 data
->auto_corr_cck
);
991 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_cck_mrc:\t\t %u\n",
992 data
->auto_corr_cck_mrc
);
994 scnprintf(buf
+ pos
, bufsz
- pos
,
995 "last_bad_plcp_cnt_ofdm:\t\t %u\n",
996 data
->last_bad_plcp_cnt_ofdm
);
998 scnprintf(buf
+ pos
, bufsz
- pos
, "last_fa_cnt_ofdm:\t\t %u\n",
999 data
->last_fa_cnt_ofdm
);
1001 scnprintf(buf
+ pos
, bufsz
- pos
, "last_bad_plcp_cnt_cck:\t\t %u\n",
1002 data
->last_bad_plcp_cnt_cck
);
1004 scnprintf(buf
+ pos
, bufsz
- pos
, "last_fa_cnt_cck:\t\t %u\n",
1005 data
->last_fa_cnt_cck
);
1007 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_curr_state:\t\t\t %u\n",
1008 data
->nrg_curr_state
);
1010 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_prev_state:\t\t\t %u\n",
1011 data
->nrg_prev_state
);
1012 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_value:\t\t\t");
1013 for (cnt
= 0; cnt
< 10; cnt
++) {
1015 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1016 data
->nrg_value
[cnt
]);
1018 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1019 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_silence_rssi:\t\t");
1020 for (cnt
= 0; cnt
< NRG_NUM_PREV_STAT_L
; cnt
++) {
1022 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1023 data
->nrg_silence_rssi
[cnt
]);
1025 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1027 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_silence_ref:\t\t %u\n",
1028 data
->nrg_silence_ref
);
1030 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_energy_idx:\t\t\t %u\n",
1031 data
->nrg_energy_idx
);
1033 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_silence_idx:\t\t %u\n",
1034 data
->nrg_silence_idx
);
1036 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_th_cck:\t\t\t %u\n",
1039 scnprintf(buf
+ pos
, bufsz
- pos
,
1040 "nrg_auto_corr_silence_diff:\t %u\n",
1041 data
->nrg_auto_corr_silence_diff
);
1043 scnprintf(buf
+ pos
, bufsz
- pos
, "num_in_cck_no_fa:\t\t %u\n",
1044 data
->num_in_cck_no_fa
);
1046 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_th_ofdm:\t\t\t %u\n",
1049 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1055 il_dbgfs_chain_noise_read(struct file
*file
, char __user
*user_buf
,
1056 size_t count
, loff_t
*ppos
)
1059 struct il_priv
*il
= file
->private_data
;
1063 int bufsz
= sizeof(struct il_chain_noise_data
) * 4 + 100;
1065 struct il_chain_noise_data
*data
;
1067 data
= &il
->chain_noise_data
;
1068 buf
= kzalloc(bufsz
, GFP_KERNEL
);
1070 IL_ERR("Can not allocate Buffer\n");
1075 scnprintf(buf
+ pos
, bufsz
- pos
, "active_chains:\t\t\t %u\n",
1076 data
->active_chains
);
1078 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_noise_a:\t\t\t %u\n",
1079 data
->chain_noise_a
);
1081 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_noise_b:\t\t\t %u\n",
1082 data
->chain_noise_b
);
1084 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_noise_c:\t\t\t %u\n",
1085 data
->chain_noise_c
);
1087 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_signal_a:\t\t\t %u\n",
1088 data
->chain_signal_a
);
1090 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_signal_b:\t\t\t %u\n",
1091 data
->chain_signal_b
);
1093 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_signal_c:\t\t\t %u\n",
1094 data
->chain_signal_c
);
1096 scnprintf(buf
+ pos
, bufsz
- pos
, "beacon_count:\t\t\t %u\n",
1097 data
->beacon_count
);
1099 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "disconn_array:\t\t\t");
1100 for (cnt
= 0; cnt
< NUM_RX_CHAINS
; cnt
++) {
1102 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1103 data
->disconn_array
[cnt
]);
1105 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1106 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "delta_gain_code:\t\t");
1107 for (cnt
= 0; cnt
< NUM_RX_CHAINS
; cnt
++) {
1109 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1110 data
->delta_gain_code
[cnt
]);
1112 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1114 scnprintf(buf
+ pos
, bufsz
- pos
, "radio_write:\t\t\t %u\n",
1117 scnprintf(buf
+ pos
, bufsz
- pos
, "state:\t\t\t\t %u\n",
1120 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1126 il_dbgfs_power_save_status_read(struct file
*file
, char __user
*user_buf
,
1127 size_t count
, loff_t
*ppos
)
1129 struct il_priv
*il
= file
->private_data
;
1132 const size_t bufsz
= sizeof(buf
);
1136 _il_rd(il
, CSR_GP_CNTRL
) & CSR_GP_REG_POWER_SAVE_STATUS_MSK
;
1138 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Power Save Status: ");
1140 scnprintf(buf
+ pos
, bufsz
- pos
, "%s\n",
1141 (pwrsave_status
== CSR_GP_REG_NO_POWER_SAVE
) ? "none" :
1142 (pwrsave_status
== CSR_GP_REG_MAC_POWER_SAVE
) ? "MAC" :
1143 (pwrsave_status
== CSR_GP_REG_PHY_POWER_SAVE
) ? "PHY" :
1146 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1150 il_dbgfs_clear_ucode_stats_write(struct file
*file
,
1151 const char __user
*user_buf
, size_t count
,
1154 struct il_priv
*il
= file
->private_data
;
1159 memset(buf
, 0, sizeof(buf
));
1160 buf_size
= min(count
, sizeof(buf
) - 1);
1161 if (copy_from_user(buf
, user_buf
, buf_size
))
1163 if (sscanf(buf
, "%d", &clear
) != 1)
1166 /* make request to uCode to retrieve stats information */
1167 mutex_lock(&il
->mutex
);
1168 il_send_stats_request(il
, CMD_SYNC
, true);
1169 mutex_unlock(&il
->mutex
);
1175 il_dbgfs_rxon_flags_read(struct file
*file
, char __user
*user_buf
,
1176 size_t count
, loff_t
*ppos
)
1179 struct il_priv
*il
= file
->private_data
;
1183 len
= sprintf(buf
, "0x%04X\n", le32_to_cpu(il
->active
.flags
));
1184 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1188 il_dbgfs_rxon_filter_flags_read(struct file
*file
, char __user
*user_buf
,
1189 size_t count
, loff_t
*ppos
)
1192 struct il_priv
*il
= file
->private_data
;
1197 sprintf(buf
, "0x%04X\n", le32_to_cpu(il
->active
.filter_flags
));
1198 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1202 il_dbgfs_fh_reg_read(struct file
*file
, char __user
*user_buf
, size_t count
,
1205 struct il_priv
*il
= file
->private_data
;
1208 ssize_t ret
= -EFAULT
;
1210 if (il
->ops
->dump_fh
) {
1211 ret
= pos
= il
->ops
->dump_fh(il
, &buf
, true);
1214 simple_read_from_buffer(user_buf
, count
, ppos
, buf
,
1224 il_dbgfs_missed_beacon_read(struct file
*file
, char __user
*user_buf
,
1225 size_t count
, loff_t
*ppos
)
1228 struct il_priv
*il
= file
->private_data
;
1231 const size_t bufsz
= sizeof(buf
);
1234 scnprintf(buf
+ pos
, bufsz
- pos
, "%d\n",
1235 il
->missed_beacon_threshold
);
1237 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1241 il_dbgfs_missed_beacon_write(struct file
*file
, const char __user
*user_buf
,
1242 size_t count
, loff_t
*ppos
)
1244 struct il_priv
*il
= file
->private_data
;
1249 memset(buf
, 0, sizeof(buf
));
1250 buf_size
= min(count
, sizeof(buf
) - 1);
1251 if (copy_from_user(buf
, user_buf
, buf_size
))
1253 if (sscanf(buf
, "%d", &missed
) != 1)
1256 if (missed
< IL_MISSED_BEACON_THRESHOLD_MIN
||
1257 missed
> IL_MISSED_BEACON_THRESHOLD_MAX
)
1258 il
->missed_beacon_threshold
= IL_MISSED_BEACON_THRESHOLD_DEF
;
1260 il
->missed_beacon_threshold
= missed
;
1266 il_dbgfs_force_reset_read(struct file
*file
, char __user
*user_buf
,
1267 size_t count
, loff_t
*ppos
)
1270 struct il_priv
*il
= file
->private_data
;
1273 const size_t bufsz
= sizeof(buf
);
1274 struct il_force_reset
*force_reset
;
1276 force_reset
= &il
->force_reset
;
1279 scnprintf(buf
+ pos
, bufsz
- pos
, "\tnumber of reset request: %d\n",
1280 force_reset
->reset_request_count
);
1282 scnprintf(buf
+ pos
, bufsz
- pos
,
1283 "\tnumber of reset request success: %d\n",
1284 force_reset
->reset_success_count
);
1286 scnprintf(buf
+ pos
, bufsz
- pos
,
1287 "\tnumber of reset request reject: %d\n",
1288 force_reset
->reset_reject_count
);
1290 scnprintf(buf
+ pos
, bufsz
- pos
, "\treset duration: %lu\n",
1291 force_reset
->reset_duration
);
1293 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1297 il_dbgfs_force_reset_write(struct file
*file
, const char __user
*user_buf
,
1298 size_t count
, loff_t
*ppos
)
1302 struct il_priv
*il
= file
->private_data
;
1304 ret
= il_force_reset(il
, true);
1306 return ret
? ret
: count
;
1310 il_dbgfs_wd_timeout_write(struct file
*file
, const char __user
*user_buf
,
1311 size_t count
, loff_t
*ppos
)
1314 struct il_priv
*il
= file
->private_data
;
1319 memset(buf
, 0, sizeof(buf
));
1320 buf_size
= min(count
, sizeof(buf
) - 1);
1321 if (copy_from_user(buf
, user_buf
, buf_size
))
1323 if (sscanf(buf
, "%d", &timeout
) != 1)
1325 if (timeout
< 0 || timeout
> IL_MAX_WD_TIMEOUT
)
1326 timeout
= IL_DEF_WD_TIMEOUT
;
1328 il
->cfg
->wd_timeout
= timeout
;
1329 il_setup_watchdog(il
);
1333 DEBUGFS_READ_FILE_OPS(rx_stats
);
1334 DEBUGFS_READ_FILE_OPS(tx_stats
);
1335 DEBUGFS_READ_FILE_OPS(rx_queue
);
1336 DEBUGFS_READ_FILE_OPS(tx_queue
);
1337 DEBUGFS_READ_FILE_OPS(ucode_rx_stats
);
1338 DEBUGFS_READ_FILE_OPS(ucode_tx_stats
);
1339 DEBUGFS_READ_FILE_OPS(ucode_general_stats
);
1340 DEBUGFS_READ_FILE_OPS(sensitivity
);
1341 DEBUGFS_READ_FILE_OPS(chain_noise
);
1342 DEBUGFS_READ_FILE_OPS(power_save_status
);
1343 DEBUGFS_WRITE_FILE_OPS(clear_ucode_stats
);
1344 DEBUGFS_WRITE_FILE_OPS(clear_traffic_stats
);
1345 DEBUGFS_READ_FILE_OPS(fh_reg
);
1346 DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon
);
1347 DEBUGFS_READ_WRITE_FILE_OPS(force_reset
);
1348 DEBUGFS_READ_FILE_OPS(rxon_flags
);
1349 DEBUGFS_READ_FILE_OPS(rxon_filter_flags
);
1350 DEBUGFS_WRITE_FILE_OPS(wd_timeout
);
1353 * Create the debugfs files and directories
1357 il_dbgfs_register(struct il_priv
*il
, const char *name
)
1359 struct dentry
*phyd
= il
->hw
->wiphy
->debugfsdir
;
1360 struct dentry
*dir_drv
, *dir_data
, *dir_rf
, *dir_debug
;
1362 dir_drv
= debugfs_create_dir(name
, phyd
);
1366 il
->debugfs_dir
= dir_drv
;
1368 dir_data
= debugfs_create_dir("data", dir_drv
);
1371 dir_rf
= debugfs_create_dir("rf", dir_drv
);
1374 dir_debug
= debugfs_create_dir("debug", dir_drv
);
1378 DEBUGFS_ADD_FILE(nvm
, dir_data
, S_IRUSR
);
1379 DEBUGFS_ADD_FILE(sram
, dir_data
, S_IWUSR
| S_IRUSR
);
1380 DEBUGFS_ADD_FILE(stations
, dir_data
, S_IRUSR
);
1381 DEBUGFS_ADD_FILE(channels
, dir_data
, S_IRUSR
);
1382 DEBUGFS_ADD_FILE(status
, dir_data
, S_IRUSR
);
1383 DEBUGFS_ADD_FILE(interrupt
, dir_data
, S_IWUSR
| S_IRUSR
);
1384 DEBUGFS_ADD_FILE(qos
, dir_data
, S_IRUSR
);
1385 DEBUGFS_ADD_FILE(disable_ht40
, dir_data
, S_IWUSR
| S_IRUSR
);
1386 DEBUGFS_ADD_FILE(rx_stats
, dir_debug
, S_IRUSR
);
1387 DEBUGFS_ADD_FILE(tx_stats
, dir_debug
, S_IRUSR
);
1388 DEBUGFS_ADD_FILE(rx_queue
, dir_debug
, S_IRUSR
);
1389 DEBUGFS_ADD_FILE(tx_queue
, dir_debug
, S_IRUSR
);
1390 DEBUGFS_ADD_FILE(power_save_status
, dir_debug
, S_IRUSR
);
1391 DEBUGFS_ADD_FILE(clear_ucode_stats
, dir_debug
, S_IWUSR
);
1392 DEBUGFS_ADD_FILE(clear_traffic_stats
, dir_debug
, S_IWUSR
);
1393 DEBUGFS_ADD_FILE(fh_reg
, dir_debug
, S_IRUSR
);
1394 DEBUGFS_ADD_FILE(missed_beacon
, dir_debug
, S_IWUSR
);
1395 DEBUGFS_ADD_FILE(force_reset
, dir_debug
, S_IWUSR
| S_IRUSR
);
1396 DEBUGFS_ADD_FILE(ucode_rx_stats
, dir_debug
, S_IRUSR
);
1397 DEBUGFS_ADD_FILE(ucode_tx_stats
, dir_debug
, S_IRUSR
);
1398 DEBUGFS_ADD_FILE(ucode_general_stats
, dir_debug
, S_IRUSR
);
1400 if (il
->cfg
->sensitivity_calib_by_driver
)
1401 DEBUGFS_ADD_FILE(sensitivity
, dir_debug
, S_IRUSR
);
1402 if (il
->cfg
->chain_noise_calib_by_driver
)
1403 DEBUGFS_ADD_FILE(chain_noise
, dir_debug
, S_IRUSR
);
1404 DEBUGFS_ADD_FILE(rxon_flags
, dir_debug
, S_IWUSR
);
1405 DEBUGFS_ADD_FILE(rxon_filter_flags
, dir_debug
, S_IWUSR
);
1406 DEBUGFS_ADD_FILE(wd_timeout
, dir_debug
, S_IWUSR
);
1407 if (il
->cfg
->sensitivity_calib_by_driver
)
1408 DEBUGFS_ADD_BOOL(disable_sensitivity
, dir_rf
,
1409 &il
->disable_sens_cal
);
1410 if (il
->cfg
->chain_noise_calib_by_driver
)
1411 DEBUGFS_ADD_BOOL(disable_chain_noise
, dir_rf
,
1412 &il
->disable_chain_noise_cal
);
1413 DEBUGFS_ADD_BOOL(disable_tx_power
, dir_rf
, &il
->disable_tx_power_cal
);
1417 IL_ERR("Can't create the debugfs directory\n");
1418 il_dbgfs_unregister(il
);
1421 EXPORT_SYMBOL(il_dbgfs_register
);
1424 * Remove the debugfs files and directories
1428 il_dbgfs_unregister(struct il_priv
*il
)
1430 if (!il
->debugfs_dir
)
1433 debugfs_remove_recursive(il
->debugfs_dir
);
1434 il
->debugfs_dir
= NULL
;
1436 EXPORT_SYMBOL(il_dbgfs_unregister
);