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 #define DEBUGFS_READ_FILE_OPS(name) \
165 DEBUGFS_READ_FUNC(name); \
166 static const struct file_operations il_dbgfs_##name##_ops = { \
167 .read = il_dbgfs_##name##_read, \
168 .open = simple_open, \
169 .llseek = generic_file_llseek, \
172 #define DEBUGFS_WRITE_FILE_OPS(name) \
173 DEBUGFS_WRITE_FUNC(name); \
174 static const struct file_operations il_dbgfs_##name##_ops = { \
175 .write = il_dbgfs_##name##_write, \
176 .open = simple_open, \
177 .llseek = generic_file_llseek, \
180 #define DEBUGFS_READ_WRITE_FILE_OPS(name) \
181 DEBUGFS_READ_FUNC(name); \
182 DEBUGFS_WRITE_FUNC(name); \
183 static const struct file_operations il_dbgfs_##name##_ops = { \
184 .write = il_dbgfs_##name##_write, \
185 .read = il_dbgfs_##name##_read, \
186 .open = simple_open, \
187 .llseek = generic_file_llseek, \
191 il_get_mgmt_string(int cmd
)
194 IL_CMD(MANAGEMENT_ASSOC_REQ
);
195 IL_CMD(MANAGEMENT_ASSOC_RESP
);
196 IL_CMD(MANAGEMENT_REASSOC_REQ
);
197 IL_CMD(MANAGEMENT_REASSOC_RESP
);
198 IL_CMD(MANAGEMENT_PROBE_REQ
);
199 IL_CMD(MANAGEMENT_PROBE_RESP
);
200 IL_CMD(MANAGEMENT_BEACON
);
201 IL_CMD(MANAGEMENT_ATIM
);
202 IL_CMD(MANAGEMENT_DISASSOC
);
203 IL_CMD(MANAGEMENT_AUTH
);
204 IL_CMD(MANAGEMENT_DEAUTH
);
205 IL_CMD(MANAGEMENT_ACTION
);
213 il_get_ctrl_string(int cmd
)
216 IL_CMD(CONTROL_BACK_REQ
);
217 IL_CMD(CONTROL_BACK
);
218 IL_CMD(CONTROL_PSPOLL
);
222 IL_CMD(CONTROL_CFEND
);
223 IL_CMD(CONTROL_CFENDACK
);
231 il_dbgfs_tx_stats_read(struct file
*file
, char __user
*user_buf
, size_t count
,
235 struct il_priv
*il
= file
->private_data
;
242 100 + sizeof(char) * 50 * (MANAGEMENT_MAX
+ CONTROL_MAX
);
243 buf
= kzalloc(bufsz
, GFP_KERNEL
);
246 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Management:\n");
247 for (cnt
= 0; cnt
< MANAGEMENT_MAX
; cnt
++) {
249 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
250 il_get_mgmt_string(cnt
), il
->tx_stats
.mgmt
[cnt
]);
252 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Control\n");
253 for (cnt
= 0; cnt
< CONTROL_MAX
; cnt
++) {
255 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
256 il_get_ctrl_string(cnt
), il
->tx_stats
.ctrl
[cnt
]);
258 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Data:\n");
260 scnprintf(buf
+ pos
, bufsz
- pos
, "\tcnt: %u\n",
261 il
->tx_stats
.data_cnt
);
263 scnprintf(buf
+ pos
, bufsz
- pos
, "\tbytes: %llu\n",
264 il
->tx_stats
.data_bytes
);
265 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
271 il_dbgfs_clear_traffic_stats_write(struct file
*file
,
272 const char __user
*user_buf
, size_t count
,
275 struct il_priv
*il
= file
->private_data
;
280 memset(buf
, 0, sizeof(buf
));
281 buf_size
= min(count
, sizeof(buf
) - 1);
282 if (copy_from_user(buf
, user_buf
, buf_size
))
284 if (sscanf(buf
, "%x", &clear_flag
) != 1)
286 il_clear_traffic_stats(il
);
292 il_dbgfs_rx_stats_read(struct file
*file
, char __user
*user_buf
, size_t count
,
296 struct il_priv
*il
= file
->private_data
;
302 100 + sizeof(char) * 50 * (MANAGEMENT_MAX
+ CONTROL_MAX
);
303 buf
= kzalloc(bufsz
, GFP_KERNEL
);
307 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Management:\n");
308 for (cnt
= 0; cnt
< MANAGEMENT_MAX
; cnt
++) {
310 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
311 il_get_mgmt_string(cnt
), il
->rx_stats
.mgmt
[cnt
]);
313 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Control:\n");
314 for (cnt
= 0; cnt
< CONTROL_MAX
; cnt
++) {
316 scnprintf(buf
+ pos
, bufsz
- pos
, "\t%25s\t\t: %u\n",
317 il_get_ctrl_string(cnt
), il
->rx_stats
.ctrl
[cnt
]);
319 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Data:\n");
321 scnprintf(buf
+ pos
, bufsz
- pos
, "\tcnt: %u\n",
322 il
->rx_stats
.data_cnt
);
324 scnprintf(buf
+ pos
, bufsz
- pos
, "\tbytes: %llu\n",
325 il
->rx_stats
.data_bytes
);
327 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
332 #define BYTE1_MASK 0x000000ff;
333 #define BYTE2_MASK 0x0000ffff;
334 #define BYTE3_MASK 0x00ffffff;
336 il_dbgfs_sram_read(struct file
*file
, char __user
*user_buf
, size_t count
,
344 struct il_priv
*il
= file
->private_data
;
347 /* default is to dump the entire data segment */
348 if (!il
->dbgfs_sram_offset
&& !il
->dbgfs_sram_len
) {
349 il
->dbgfs_sram_offset
= 0x800000;
350 if (il
->ucode_type
== UCODE_INIT
)
351 il
->dbgfs_sram_len
= il
->ucode_init_data
.len
;
353 il
->dbgfs_sram_len
= il
->ucode_data
.len
;
355 bufsz
= 30 + il
->dbgfs_sram_len
* sizeof(char) * 10;
356 buf
= kmalloc(bufsz
, GFP_KERNEL
);
360 scnprintf(buf
+ pos
, bufsz
- pos
, "sram_len: 0x%x\n",
363 scnprintf(buf
+ pos
, bufsz
- pos
, "sram_offset: 0x%x\n",
364 il
->dbgfs_sram_offset
);
365 for (i
= il
->dbgfs_sram_len
; i
> 0; i
-= 4) {
368 il
->dbgfs_sram_offset
+
369 il
->dbgfs_sram_len
- i
);
384 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
385 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "0x%08x ", val
);
387 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
389 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
395 il_dbgfs_sram_write(struct file
*file
, const char __user
*user_buf
,
396 size_t count
, loff_t
*ppos
)
398 struct il_priv
*il
= file
->private_data
;
403 memset(buf
, 0, sizeof(buf
));
404 buf_size
= min(count
, sizeof(buf
) - 1);
405 if (copy_from_user(buf
, user_buf
, buf_size
))
408 if (sscanf(buf
, "%x,%x", &offset
, &len
) == 2) {
409 il
->dbgfs_sram_offset
= offset
;
410 il
->dbgfs_sram_len
= len
;
412 il
->dbgfs_sram_offset
= 0;
413 il
->dbgfs_sram_len
= 0;
420 il_dbgfs_stations_read(struct file
*file
, char __user
*user_buf
, size_t count
,
423 struct il_priv
*il
= file
->private_data
;
424 struct il_station_entry
*station
;
425 int max_sta
= il
->hw_params
.max_stations
;
429 /* Add 30 for initial string */
430 const size_t bufsz
= 30 + sizeof(char) * 500 * (il
->num_stations
);
432 buf
= kmalloc(bufsz
, GFP_KERNEL
);
437 scnprintf(buf
+ pos
, bufsz
- pos
, "num of stations: %d\n\n",
440 for (i
= 0; i
< max_sta
; i
++) {
441 station
= &il
->stations
[i
];
445 scnprintf(buf
+ pos
, bufsz
- pos
,
446 "station %d - addr: %pM, flags: %#x\n", i
,
447 station
->sta
.sta
.addr
,
448 station
->sta
.station_flags_msk
);
450 scnprintf(buf
+ pos
, bufsz
- pos
,
451 "TID\tseq_num\ttxq_id\tframes\ttfds\t");
453 scnprintf(buf
+ pos
, bufsz
- pos
,
454 "start_idx\tbitmap\t\t\trate_n_flags\n");
456 for (j
= 0; j
< MAX_TID_COUNT
; j
++) {
458 scnprintf(buf
+ pos
, bufsz
- pos
,
459 "%d:\t%#x\t%#x\t%u\t%u\t%u\t\t%#.16llx\t%#x",
460 j
, station
->tid
[j
].seq_number
,
461 station
->tid
[j
].agg
.txq_id
,
462 station
->tid
[j
].agg
.frame_count
,
463 station
->tid
[j
].tfds_in_queue
,
464 station
->tid
[j
].agg
.start_idx
,
465 station
->tid
[j
].agg
.bitmap
,
466 station
->tid
[j
].agg
.rate_n_flags
);
468 if (station
->tid
[j
].agg
.wait_for_ba
)
470 scnprintf(buf
+ pos
, bufsz
- pos
,
472 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
475 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
478 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
484 il_dbgfs_nvm_read(struct file
*file
, char __user
*user_buf
, size_t count
,
488 struct il_priv
*il
= file
->private_data
;
489 int pos
= 0, ofs
= 0, buf_size
= 0;
493 size_t eeprom_len
= il
->cfg
->eeprom_size
;
494 buf_size
= 4 * eeprom_len
+ 256;
496 if (eeprom_len
% 16) {
497 IL_ERR("NVM size is not multiple of 16.\n");
503 IL_ERR("Invalid EEPROM memory\n");
507 /* 4 characters for byte 0xYY */
508 buf
= kzalloc(buf_size
, GFP_KERNEL
);
510 IL_ERR("Can not allocate Buffer\n");
513 eeprom_ver
= il_eeprom_query16(il
, EEPROM_VERSION
);
515 scnprintf(buf
+ pos
, buf_size
- pos
, "EEPROM " "version: 0x%x\n",
517 for (ofs
= 0; ofs
< eeprom_len
; ofs
+= 16) {
518 pos
+= scnprintf(buf
+ pos
, buf_size
- pos
, "0x%.4x %16ph\n",
522 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
528 il_dbgfs_channels_read(struct file
*file
, char __user
*user_buf
, size_t count
,
531 struct il_priv
*il
= file
->private_data
;
532 struct ieee80211_channel
*channels
= NULL
;
533 const struct ieee80211_supported_band
*supp_band
= NULL
;
534 int pos
= 0, i
, bufsz
= PAGE_SIZE
;
538 if (!test_bit(S_GEO_CONFIGURED
, &il
->status
))
541 buf
= kzalloc(bufsz
, GFP_KERNEL
);
543 IL_ERR("Can not allocate Buffer\n");
547 supp_band
= il_get_hw_mode(il
, IEEE80211_BAND_2GHZ
);
549 channels
= supp_band
->channels
;
552 scnprintf(buf
+ pos
, bufsz
- pos
,
553 "Displaying %d channels in 2.4GHz band 802.11bg):\n",
554 supp_band
->n_channels
);
556 for (i
= 0; i
< supp_band
->n_channels
; i
++)
558 scnprintf(buf
+ pos
, bufsz
- pos
,
559 "%d: %ddBm: BSS%s%s, %s.\n",
560 channels
[i
].hw_value
,
561 channels
[i
].max_power
,
563 flags
& IEEE80211_CHAN_RADAR
?
564 " (IEEE 802.11h required)" : "",
566 flags
& IEEE80211_CHAN_NO_IR
) ||
568 flags
& IEEE80211_CHAN_RADAR
)) ? "" :
571 flags
& IEEE80211_CHAN_NO_IR
?
572 "passive only" : "active/passive");
574 supp_band
= il_get_hw_mode(il
, IEEE80211_BAND_5GHZ
);
576 channels
= supp_band
->channels
;
579 scnprintf(buf
+ pos
, bufsz
- pos
,
580 "Displaying %d channels in 5.2GHz band (802.11a)\n",
581 supp_band
->n_channels
);
583 for (i
= 0; i
< supp_band
->n_channels
; i
++)
585 scnprintf(buf
+ pos
, bufsz
- pos
,
586 "%d: %ddBm: BSS%s%s, %s.\n",
587 channels
[i
].hw_value
,
588 channels
[i
].max_power
,
590 flags
& IEEE80211_CHAN_RADAR
?
591 " (IEEE 802.11h required)" : "",
593 flags
& IEEE80211_CHAN_NO_IR
) ||
595 flags
& IEEE80211_CHAN_RADAR
)) ? "" :
598 flags
& IEEE80211_CHAN_NO_IR
?
599 "passive only" : "active/passive");
601 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
607 il_dbgfs_status_read(struct file
*file
, char __user
*user_buf
, size_t count
,
611 struct il_priv
*il
= file
->private_data
;
614 const size_t bufsz
= sizeof(buf
);
617 scnprintf(buf
+ pos
, bufsz
- pos
, "S_HCMD_ACTIVE:\t %d\n",
618 test_bit(S_HCMD_ACTIVE
, &il
->status
));
620 scnprintf(buf
+ pos
, bufsz
- pos
, "S_INT_ENABLED:\t %d\n",
621 test_bit(S_INT_ENABLED
, &il
->status
));
623 scnprintf(buf
+ pos
, bufsz
- pos
, "S_RFKILL:\t %d\n",
624 test_bit(S_RFKILL
, &il
->status
));
626 scnprintf(buf
+ pos
, bufsz
- pos
, "S_CT_KILL:\t\t %d\n",
627 test_bit(S_CT_KILL
, &il
->status
));
629 scnprintf(buf
+ pos
, bufsz
- pos
, "S_INIT:\t\t %d\n",
630 test_bit(S_INIT
, &il
->status
));
632 scnprintf(buf
+ pos
, bufsz
- pos
, "S_ALIVE:\t\t %d\n",
633 test_bit(S_ALIVE
, &il
->status
));
635 scnprintf(buf
+ pos
, bufsz
- pos
, "S_READY:\t\t %d\n",
636 test_bit(S_READY
, &il
->status
));
638 scnprintf(buf
+ pos
, bufsz
- pos
, "S_TEMPERATURE:\t %d\n",
639 test_bit(S_TEMPERATURE
, &il
->status
));
641 scnprintf(buf
+ pos
, bufsz
- pos
, "S_GEO_CONFIGURED:\t %d\n",
642 test_bit(S_GEO_CONFIGURED
, &il
->status
));
644 scnprintf(buf
+ pos
, bufsz
- pos
, "S_EXIT_PENDING:\t %d\n",
645 test_bit(S_EXIT_PENDING
, &il
->status
));
647 scnprintf(buf
+ pos
, bufsz
- pos
, "S_STATS:\t %d\n",
648 test_bit(S_STATS
, &il
->status
));
650 scnprintf(buf
+ pos
, bufsz
- pos
, "S_SCANNING:\t %d\n",
651 test_bit(S_SCANNING
, &il
->status
));
653 scnprintf(buf
+ pos
, bufsz
- pos
, "S_SCAN_ABORTING:\t %d\n",
654 test_bit(S_SCAN_ABORTING
, &il
->status
));
656 scnprintf(buf
+ pos
, bufsz
- pos
, "S_SCAN_HW:\t\t %d\n",
657 test_bit(S_SCAN_HW
, &il
->status
));
659 scnprintf(buf
+ pos
, bufsz
- pos
, "S_POWER_PMI:\t %d\n",
660 test_bit(S_POWER_PMI
, &il
->status
));
662 scnprintf(buf
+ pos
, bufsz
- pos
, "S_FW_ERROR:\t %d\n",
663 test_bit(S_FW_ERROR
, &il
->status
));
664 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
668 il_dbgfs_interrupt_read(struct file
*file
, char __user
*user_buf
, size_t count
,
672 struct il_priv
*il
= file
->private_data
;
676 int bufsz
= 24 * 64; /* 24 items * 64 char per item */
679 buf
= kzalloc(bufsz
, GFP_KERNEL
);
681 IL_ERR("Can not allocate Buffer\n");
686 scnprintf(buf
+ pos
, bufsz
- pos
, "Interrupt Statistics Report:\n");
689 scnprintf(buf
+ pos
, bufsz
- pos
, "HW Error:\t\t\t %u\n",
692 scnprintf(buf
+ pos
, bufsz
- pos
, "SW Error:\t\t\t %u\n",
694 if (il
->isr_stats
.sw
|| il
->isr_stats
.hw
) {
696 scnprintf(buf
+ pos
, bufsz
- pos
,
697 "\tLast Restarting Code: 0x%X\n",
698 il
->isr_stats
.err_code
);
700 #ifdef CONFIG_IWLEGACY_DEBUG
702 scnprintf(buf
+ pos
, bufsz
- pos
, "Frame transmitted:\t\t %u\n",
705 scnprintf(buf
+ pos
, bufsz
- pos
, "Alive interrupt:\t\t %u\n",
706 il
->isr_stats
.alive
);
709 scnprintf(buf
+ pos
, bufsz
- pos
,
710 "HW RF KILL switch toggled:\t %u\n",
711 il
->isr_stats
.rfkill
);
714 scnprintf(buf
+ pos
, bufsz
- pos
, "CT KILL:\t\t\t %u\n",
715 il
->isr_stats
.ctkill
);
718 scnprintf(buf
+ pos
, bufsz
- pos
, "Wakeup Interrupt:\t\t %u\n",
719 il
->isr_stats
.wakeup
);
722 scnprintf(buf
+ pos
, bufsz
- pos
, "Rx command responses:\t\t %u\n",
724 for (cnt
= 0; cnt
< IL_CN_MAX
; cnt
++) {
725 if (il
->isr_stats
.handlers
[cnt
] > 0)
727 scnprintf(buf
+ pos
, bufsz
- pos
,
728 "\tRx handler[%36s]:\t\t %u\n",
729 il_get_cmd_string(cnt
),
730 il
->isr_stats
.handlers
[cnt
]);
734 scnprintf(buf
+ pos
, bufsz
- pos
, "Tx/FH interrupt:\t\t %u\n",
738 scnprintf(buf
+ pos
, bufsz
- pos
, "Unexpected INTA:\t\t %u\n",
739 il
->isr_stats
.unhandled
);
741 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
747 il_dbgfs_interrupt_write(struct file
*file
, const char __user
*user_buf
,
748 size_t count
, loff_t
*ppos
)
750 struct il_priv
*il
= file
->private_data
;
755 memset(buf
, 0, sizeof(buf
));
756 buf_size
= min(count
, sizeof(buf
) - 1);
757 if (copy_from_user(buf
, user_buf
, buf_size
))
759 if (sscanf(buf
, "%x", &reset_flag
) != 1)
762 il_clear_isr_stats(il
);
768 il_dbgfs_qos_read(struct file
*file
, char __user
*user_buf
, size_t count
,
771 struct il_priv
*il
= file
->private_data
;
774 const size_t bufsz
= sizeof(buf
);
776 for (i
= 0; i
< AC_NUM
; i
++) {
778 scnprintf(buf
+ pos
, bufsz
- pos
,
779 "\tcw_min\tcw_max\taifsn\ttxop\n");
781 scnprintf(buf
+ pos
, bufsz
- pos
,
782 "AC[%d]\t%u\t%u\t%u\t%u\n", i
,
783 il
->qos_data
.def_qos_parm
.ac
[i
].cw_min
,
784 il
->qos_data
.def_qos_parm
.ac
[i
].cw_max
,
785 il
->qos_data
.def_qos_parm
.ac
[i
].aifsn
,
786 il
->qos_data
.def_qos_parm
.ac
[i
].edca_txop
);
789 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
793 il_dbgfs_disable_ht40_write(struct file
*file
, const char __user
*user_buf
,
794 size_t count
, loff_t
*ppos
)
796 struct il_priv
*il
= file
->private_data
;
801 memset(buf
, 0, sizeof(buf
));
802 buf_size
= min(count
, sizeof(buf
) - 1);
803 if (copy_from_user(buf
, user_buf
, buf_size
))
805 if (sscanf(buf
, "%d", &ht40
) != 1)
807 if (!il_is_any_associated(il
))
808 il
->disable_ht40
= ht40
? true : false;
810 IL_ERR("Sta associated with AP - "
811 "Change to 40MHz channel support is not allowed\n");
819 il_dbgfs_disable_ht40_read(struct file
*file
, char __user
*user_buf
,
820 size_t count
, loff_t
*ppos
)
822 struct il_priv
*il
= file
->private_data
;
825 const size_t bufsz
= sizeof(buf
);
828 scnprintf(buf
+ pos
, bufsz
- pos
, "11n 40MHz Mode: %s\n",
829 il
->disable_ht40
? "Disabled" : "Enabled");
830 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
833 DEBUGFS_READ_WRITE_FILE_OPS(sram
);
834 DEBUGFS_READ_FILE_OPS(nvm
);
835 DEBUGFS_READ_FILE_OPS(stations
);
836 DEBUGFS_READ_FILE_OPS(channels
);
837 DEBUGFS_READ_FILE_OPS(status
);
838 DEBUGFS_READ_WRITE_FILE_OPS(interrupt
);
839 DEBUGFS_READ_FILE_OPS(qos
);
840 DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40
);
843 il_dbgfs_tx_queue_read(struct file
*file
, char __user
*user_buf
, size_t count
,
847 struct il_priv
*il
= file
->private_data
;
848 struct il_tx_queue
*txq
;
855 sizeof(char) * 64 * il
->cfg
->num_of_queues
;
858 IL_ERR("txq not ready\n");
861 buf
= kzalloc(bufsz
, GFP_KERNEL
);
865 for (cnt
= 0; cnt
< il
->hw_params
.max_txq_num
; cnt
++) {
869 scnprintf(buf
+ pos
, bufsz
- pos
,
870 "hwq %.2d: read=%u write=%u stop=%d"
871 " swq_id=%#.2x (ac %d/hwq %d)\n", cnt
,
872 q
->read_ptr
, q
->write_ptr
,
873 !!test_bit(cnt
, il
->queue_stopped
),
874 txq
->swq_id
, txq
->swq_id
& 3,
875 (txq
->swq_id
>> 2) & 0x1f);
878 /* for the ACs, display the stop count too */
880 scnprintf(buf
+ pos
, bufsz
- pos
,
882 atomic_read(&il
->queue_stop_count
[cnt
]));
884 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
890 il_dbgfs_rx_queue_read(struct file
*file
, char __user
*user_buf
, size_t count
,
894 struct il_priv
*il
= file
->private_data
;
895 struct il_rx_queue
*rxq
= &il
->rxq
;
898 const size_t bufsz
= sizeof(buf
);
900 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "read: %u\n", rxq
->read
);
901 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "write: %u\n", rxq
->write
);
903 scnprintf(buf
+ pos
, bufsz
- pos
, "free_count: %u\n",
907 scnprintf(buf
+ pos
, bufsz
- pos
, "closed_rb_num: %u\n",
908 le16_to_cpu(rxq
->rb_stts
->
909 closed_rb_num
) & 0x0FFF);
912 scnprintf(buf
+ pos
, bufsz
- pos
,
913 "closed_rb_num: Not Allocated\n");
915 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
919 il_dbgfs_ucode_rx_stats_read(struct file
*file
, char __user
*user_buf
,
920 size_t count
, loff_t
*ppos
)
922 struct il_priv
*il
= file
->private_data
;
924 return il
->debugfs_ops
->rx_stats_read(file
, user_buf
, count
, ppos
);
928 il_dbgfs_ucode_tx_stats_read(struct file
*file
, char __user
*user_buf
,
929 size_t count
, loff_t
*ppos
)
931 struct il_priv
*il
= file
->private_data
;
933 return il
->debugfs_ops
->tx_stats_read(file
, user_buf
, count
, ppos
);
937 il_dbgfs_ucode_general_stats_read(struct file
*file
, char __user
*user_buf
,
938 size_t count
, loff_t
*ppos
)
940 struct il_priv
*il
= file
->private_data
;
942 return il
->debugfs_ops
->general_stats_read(file
, user_buf
, count
, ppos
);
946 il_dbgfs_sensitivity_read(struct file
*file
, char __user
*user_buf
,
947 size_t count
, loff_t
*ppos
)
950 struct il_priv
*il
= file
->private_data
;
954 int bufsz
= sizeof(struct il_sensitivity_data
) * 4 + 100;
956 struct il_sensitivity_data
*data
;
958 data
= &il
->sensitivity_data
;
959 buf
= kzalloc(bufsz
, GFP_KERNEL
);
961 IL_ERR("Can not allocate Buffer\n");
966 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm:\t\t\t %u\n",
967 data
->auto_corr_ofdm
);
969 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm_mrc:\t\t %u\n",
970 data
->auto_corr_ofdm_mrc
);
972 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm_x1:\t\t %u\n",
973 data
->auto_corr_ofdm_x1
);
975 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_ofdm_mrc_x1:\t\t %u\n",
976 data
->auto_corr_ofdm_mrc_x1
);
978 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_cck:\t\t\t %u\n",
979 data
->auto_corr_cck
);
981 scnprintf(buf
+ pos
, bufsz
- pos
, "auto_corr_cck_mrc:\t\t %u\n",
982 data
->auto_corr_cck_mrc
);
984 scnprintf(buf
+ pos
, bufsz
- pos
,
985 "last_bad_plcp_cnt_ofdm:\t\t %u\n",
986 data
->last_bad_plcp_cnt_ofdm
);
988 scnprintf(buf
+ pos
, bufsz
- pos
, "last_fa_cnt_ofdm:\t\t %u\n",
989 data
->last_fa_cnt_ofdm
);
991 scnprintf(buf
+ pos
, bufsz
- pos
, "last_bad_plcp_cnt_cck:\t\t %u\n",
992 data
->last_bad_plcp_cnt_cck
);
994 scnprintf(buf
+ pos
, bufsz
- pos
, "last_fa_cnt_cck:\t\t %u\n",
995 data
->last_fa_cnt_cck
);
997 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_curr_state:\t\t\t %u\n",
998 data
->nrg_curr_state
);
1000 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_prev_state:\t\t\t %u\n",
1001 data
->nrg_prev_state
);
1002 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_value:\t\t\t");
1003 for (cnt
= 0; cnt
< 10; cnt
++) {
1005 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1006 data
->nrg_value
[cnt
]);
1008 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1009 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_silence_rssi:\t\t");
1010 for (cnt
= 0; cnt
< NRG_NUM_PREV_STAT_L
; cnt
++) {
1012 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1013 data
->nrg_silence_rssi
[cnt
]);
1015 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1017 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_silence_ref:\t\t %u\n",
1018 data
->nrg_silence_ref
);
1020 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_energy_idx:\t\t\t %u\n",
1021 data
->nrg_energy_idx
);
1023 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_silence_idx:\t\t %u\n",
1024 data
->nrg_silence_idx
);
1026 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_th_cck:\t\t\t %u\n",
1029 scnprintf(buf
+ pos
, bufsz
- pos
,
1030 "nrg_auto_corr_silence_diff:\t %u\n",
1031 data
->nrg_auto_corr_silence_diff
);
1033 scnprintf(buf
+ pos
, bufsz
- pos
, "num_in_cck_no_fa:\t\t %u\n",
1034 data
->num_in_cck_no_fa
);
1036 scnprintf(buf
+ pos
, bufsz
- pos
, "nrg_th_ofdm:\t\t\t %u\n",
1039 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1045 il_dbgfs_chain_noise_read(struct file
*file
, char __user
*user_buf
,
1046 size_t count
, loff_t
*ppos
)
1049 struct il_priv
*il
= file
->private_data
;
1053 int bufsz
= sizeof(struct il_chain_noise_data
) * 4 + 100;
1055 struct il_chain_noise_data
*data
;
1057 data
= &il
->chain_noise_data
;
1058 buf
= kzalloc(bufsz
, GFP_KERNEL
);
1060 IL_ERR("Can not allocate Buffer\n");
1065 scnprintf(buf
+ pos
, bufsz
- pos
, "active_chains:\t\t\t %u\n",
1066 data
->active_chains
);
1068 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_noise_a:\t\t\t %u\n",
1069 data
->chain_noise_a
);
1071 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_noise_b:\t\t\t %u\n",
1072 data
->chain_noise_b
);
1074 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_noise_c:\t\t\t %u\n",
1075 data
->chain_noise_c
);
1077 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_signal_a:\t\t\t %u\n",
1078 data
->chain_signal_a
);
1080 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_signal_b:\t\t\t %u\n",
1081 data
->chain_signal_b
);
1083 scnprintf(buf
+ pos
, bufsz
- pos
, "chain_signal_c:\t\t\t %u\n",
1084 data
->chain_signal_c
);
1086 scnprintf(buf
+ pos
, bufsz
- pos
, "beacon_count:\t\t\t %u\n",
1087 data
->beacon_count
);
1089 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "disconn_array:\t\t\t");
1090 for (cnt
= 0; cnt
< NUM_RX_CHAINS
; cnt
++) {
1092 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1093 data
->disconn_array
[cnt
]);
1095 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1096 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "delta_gain_code:\t\t");
1097 for (cnt
= 0; cnt
< NUM_RX_CHAINS
; cnt
++) {
1099 scnprintf(buf
+ pos
, bufsz
- pos
, " %u",
1100 data
->delta_gain_code
[cnt
]);
1102 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "\n");
1104 scnprintf(buf
+ pos
, bufsz
- pos
, "radio_write:\t\t\t %u\n",
1107 scnprintf(buf
+ pos
, bufsz
- pos
, "state:\t\t\t\t %u\n",
1110 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1116 il_dbgfs_power_save_status_read(struct file
*file
, char __user
*user_buf
,
1117 size_t count
, loff_t
*ppos
)
1119 struct il_priv
*il
= file
->private_data
;
1122 const size_t bufsz
= sizeof(buf
);
1126 _il_rd(il
, CSR_GP_CNTRL
) & CSR_GP_REG_POWER_SAVE_STATUS_MSK
;
1128 pos
+= scnprintf(buf
+ pos
, bufsz
- pos
, "Power Save Status: ");
1130 scnprintf(buf
+ pos
, bufsz
- pos
, "%s\n",
1131 (pwrsave_status
== CSR_GP_REG_NO_POWER_SAVE
) ? "none" :
1132 (pwrsave_status
== CSR_GP_REG_MAC_POWER_SAVE
) ? "MAC" :
1133 (pwrsave_status
== CSR_GP_REG_PHY_POWER_SAVE
) ? "PHY" :
1136 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1140 il_dbgfs_clear_ucode_stats_write(struct file
*file
,
1141 const char __user
*user_buf
, size_t count
,
1144 struct il_priv
*il
= file
->private_data
;
1149 memset(buf
, 0, sizeof(buf
));
1150 buf_size
= min(count
, sizeof(buf
) - 1);
1151 if (copy_from_user(buf
, user_buf
, buf_size
))
1153 if (sscanf(buf
, "%d", &clear
) != 1)
1156 /* make request to uCode to retrieve stats information */
1157 mutex_lock(&il
->mutex
);
1158 il_send_stats_request(il
, CMD_SYNC
, true);
1159 mutex_unlock(&il
->mutex
);
1165 il_dbgfs_rxon_flags_read(struct file
*file
, char __user
*user_buf
,
1166 size_t count
, loff_t
*ppos
)
1169 struct il_priv
*il
= file
->private_data
;
1173 len
= sprintf(buf
, "0x%04X\n", le32_to_cpu(il
->active
.flags
));
1174 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1178 il_dbgfs_rxon_filter_flags_read(struct file
*file
, char __user
*user_buf
,
1179 size_t count
, loff_t
*ppos
)
1182 struct il_priv
*il
= file
->private_data
;
1187 sprintf(buf
, "0x%04X\n", le32_to_cpu(il
->active
.filter_flags
));
1188 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1192 il_dbgfs_fh_reg_read(struct file
*file
, char __user
*user_buf
, size_t count
,
1195 struct il_priv
*il
= file
->private_data
;
1198 ssize_t ret
= -EFAULT
;
1200 if (il
->ops
->dump_fh
) {
1201 ret
= pos
= il
->ops
->dump_fh(il
, &buf
, true);
1204 simple_read_from_buffer(user_buf
, count
, ppos
, buf
,
1214 il_dbgfs_missed_beacon_read(struct file
*file
, char __user
*user_buf
,
1215 size_t count
, loff_t
*ppos
)
1218 struct il_priv
*il
= file
->private_data
;
1221 const size_t bufsz
= sizeof(buf
);
1224 scnprintf(buf
+ pos
, bufsz
- pos
, "%d\n",
1225 il
->missed_beacon_threshold
);
1227 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1231 il_dbgfs_missed_beacon_write(struct file
*file
, const char __user
*user_buf
,
1232 size_t count
, loff_t
*ppos
)
1234 struct il_priv
*il
= file
->private_data
;
1239 memset(buf
, 0, sizeof(buf
));
1240 buf_size
= min(count
, sizeof(buf
) - 1);
1241 if (copy_from_user(buf
, user_buf
, buf_size
))
1243 if (sscanf(buf
, "%d", &missed
) != 1)
1246 if (missed
< IL_MISSED_BEACON_THRESHOLD_MIN
||
1247 missed
> IL_MISSED_BEACON_THRESHOLD_MAX
)
1248 il
->missed_beacon_threshold
= IL_MISSED_BEACON_THRESHOLD_DEF
;
1250 il
->missed_beacon_threshold
= missed
;
1256 il_dbgfs_force_reset_read(struct file
*file
, char __user
*user_buf
,
1257 size_t count
, loff_t
*ppos
)
1260 struct il_priv
*il
= file
->private_data
;
1263 const size_t bufsz
= sizeof(buf
);
1264 struct il_force_reset
*force_reset
;
1266 force_reset
= &il
->force_reset
;
1269 scnprintf(buf
+ pos
, bufsz
- pos
, "\tnumber of reset request: %d\n",
1270 force_reset
->reset_request_count
);
1272 scnprintf(buf
+ pos
, bufsz
- pos
,
1273 "\tnumber of reset request success: %d\n",
1274 force_reset
->reset_success_count
);
1276 scnprintf(buf
+ pos
, bufsz
- pos
,
1277 "\tnumber of reset request reject: %d\n",
1278 force_reset
->reset_reject_count
);
1280 scnprintf(buf
+ pos
, bufsz
- pos
, "\treset duration: %lu\n",
1281 force_reset
->reset_duration
);
1283 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, pos
);
1287 il_dbgfs_force_reset_write(struct file
*file
, const char __user
*user_buf
,
1288 size_t count
, loff_t
*ppos
)
1292 struct il_priv
*il
= file
->private_data
;
1294 ret
= il_force_reset(il
, true);
1296 return ret
? ret
: count
;
1300 il_dbgfs_wd_timeout_write(struct file
*file
, const char __user
*user_buf
,
1301 size_t count
, loff_t
*ppos
)
1304 struct il_priv
*il
= file
->private_data
;
1309 memset(buf
, 0, sizeof(buf
));
1310 buf_size
= min(count
, sizeof(buf
) - 1);
1311 if (copy_from_user(buf
, user_buf
, buf_size
))
1313 if (sscanf(buf
, "%d", &timeout
) != 1)
1315 if (timeout
< 0 || timeout
> IL_MAX_WD_TIMEOUT
)
1316 timeout
= IL_DEF_WD_TIMEOUT
;
1318 il
->cfg
->wd_timeout
= timeout
;
1319 il_setup_watchdog(il
);
1323 DEBUGFS_READ_FILE_OPS(rx_stats
);
1324 DEBUGFS_READ_FILE_OPS(tx_stats
);
1325 DEBUGFS_READ_FILE_OPS(rx_queue
);
1326 DEBUGFS_READ_FILE_OPS(tx_queue
);
1327 DEBUGFS_READ_FILE_OPS(ucode_rx_stats
);
1328 DEBUGFS_READ_FILE_OPS(ucode_tx_stats
);
1329 DEBUGFS_READ_FILE_OPS(ucode_general_stats
);
1330 DEBUGFS_READ_FILE_OPS(sensitivity
);
1331 DEBUGFS_READ_FILE_OPS(chain_noise
);
1332 DEBUGFS_READ_FILE_OPS(power_save_status
);
1333 DEBUGFS_WRITE_FILE_OPS(clear_ucode_stats
);
1334 DEBUGFS_WRITE_FILE_OPS(clear_traffic_stats
);
1335 DEBUGFS_READ_FILE_OPS(fh_reg
);
1336 DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon
);
1337 DEBUGFS_READ_WRITE_FILE_OPS(force_reset
);
1338 DEBUGFS_READ_FILE_OPS(rxon_flags
);
1339 DEBUGFS_READ_FILE_OPS(rxon_filter_flags
);
1340 DEBUGFS_WRITE_FILE_OPS(wd_timeout
);
1343 * Create the debugfs files and directories
1347 il_dbgfs_register(struct il_priv
*il
, const char *name
)
1349 struct dentry
*phyd
= il
->hw
->wiphy
->debugfsdir
;
1350 struct dentry
*dir_drv
, *dir_data
, *dir_rf
, *dir_debug
;
1352 dir_drv
= debugfs_create_dir(name
, phyd
);
1356 il
->debugfs_dir
= dir_drv
;
1358 dir_data
= debugfs_create_dir("data", dir_drv
);
1361 dir_rf
= debugfs_create_dir("rf", dir_drv
);
1364 dir_debug
= debugfs_create_dir("debug", dir_drv
);
1368 DEBUGFS_ADD_FILE(nvm
, dir_data
, S_IRUSR
);
1369 DEBUGFS_ADD_FILE(sram
, dir_data
, S_IWUSR
| S_IRUSR
);
1370 DEBUGFS_ADD_FILE(stations
, dir_data
, S_IRUSR
);
1371 DEBUGFS_ADD_FILE(channels
, dir_data
, S_IRUSR
);
1372 DEBUGFS_ADD_FILE(status
, dir_data
, S_IRUSR
);
1373 DEBUGFS_ADD_FILE(interrupt
, dir_data
, S_IWUSR
| S_IRUSR
);
1374 DEBUGFS_ADD_FILE(qos
, dir_data
, S_IRUSR
);
1375 DEBUGFS_ADD_FILE(disable_ht40
, dir_data
, S_IWUSR
| S_IRUSR
);
1376 DEBUGFS_ADD_FILE(rx_stats
, dir_debug
, S_IRUSR
);
1377 DEBUGFS_ADD_FILE(tx_stats
, dir_debug
, S_IRUSR
);
1378 DEBUGFS_ADD_FILE(rx_queue
, dir_debug
, S_IRUSR
);
1379 DEBUGFS_ADD_FILE(tx_queue
, dir_debug
, S_IRUSR
);
1380 DEBUGFS_ADD_FILE(power_save_status
, dir_debug
, S_IRUSR
);
1381 DEBUGFS_ADD_FILE(clear_ucode_stats
, dir_debug
, S_IWUSR
);
1382 DEBUGFS_ADD_FILE(clear_traffic_stats
, dir_debug
, S_IWUSR
);
1383 DEBUGFS_ADD_FILE(fh_reg
, dir_debug
, S_IRUSR
);
1384 DEBUGFS_ADD_FILE(missed_beacon
, dir_debug
, S_IWUSR
);
1385 DEBUGFS_ADD_FILE(force_reset
, dir_debug
, S_IWUSR
| S_IRUSR
);
1386 DEBUGFS_ADD_FILE(ucode_rx_stats
, dir_debug
, S_IRUSR
);
1387 DEBUGFS_ADD_FILE(ucode_tx_stats
, dir_debug
, S_IRUSR
);
1388 DEBUGFS_ADD_FILE(ucode_general_stats
, dir_debug
, S_IRUSR
);
1390 if (il
->cfg
->sensitivity_calib_by_driver
)
1391 DEBUGFS_ADD_FILE(sensitivity
, dir_debug
, S_IRUSR
);
1392 if (il
->cfg
->chain_noise_calib_by_driver
)
1393 DEBUGFS_ADD_FILE(chain_noise
, dir_debug
, S_IRUSR
);
1394 DEBUGFS_ADD_FILE(rxon_flags
, dir_debug
, S_IWUSR
);
1395 DEBUGFS_ADD_FILE(rxon_filter_flags
, dir_debug
, S_IWUSR
);
1396 DEBUGFS_ADD_FILE(wd_timeout
, dir_debug
, S_IWUSR
);
1397 if (il
->cfg
->sensitivity_calib_by_driver
)
1398 DEBUGFS_ADD_BOOL(disable_sensitivity
, dir_rf
,
1399 &il
->disable_sens_cal
);
1400 if (il
->cfg
->chain_noise_calib_by_driver
)
1401 DEBUGFS_ADD_BOOL(disable_chain_noise
, dir_rf
,
1402 &il
->disable_chain_noise_cal
);
1403 DEBUGFS_ADD_BOOL(disable_tx_power
, dir_rf
, &il
->disable_tx_power_cal
);
1407 IL_ERR("Can't create the debugfs directory\n");
1408 il_dbgfs_unregister(il
);
1411 EXPORT_SYMBOL(il_dbgfs_register
);
1414 * Remove the debugfs files and directories
1418 il_dbgfs_unregister(struct il_priv
*il
)
1420 if (!il
->debugfs_dir
)
1423 debugfs_remove_recursive(il
->debugfs_dir
);
1424 il
->debugfs_dir
= NULL
;
1426 EXPORT_SYMBOL(il_dbgfs_unregister
);