1 /******************************************************************************
5 * Copyright(c) 2008 - 2014 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 COPYING.
24 * Contact Information:
25 * Intel Linux Wireless <linuxwifi@intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *****************************************************************************/
29 #include <linux/slab.h>
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/debugfs.h>
33 #include <linux/ieee80211.h>
34 #include <net/mac80211.h>
36 #include "iwl-debug.h"
37 #include "iwl-trans.h"
42 /* create and remove of files */
43 #define DEBUGFS_ADD_FILE(name, parent, mode) do { \
44 if (!debugfs_create_file(#name, mode, parent, priv, \
45 &iwl_dbgfs_##name##_ops)) \
49 #define DEBUGFS_ADD_BOOL(name, parent, ptr) do { \
50 struct dentry *__tmp; \
51 __tmp = debugfs_create_bool(#name, 0600, parent, ptr); \
52 if (IS_ERR(__tmp) || !__tmp) \
56 #define DEBUGFS_ADD_X32(name, parent, ptr) do { \
57 struct dentry *__tmp; \
58 __tmp = debugfs_create_x32(#name, 0600, parent, ptr); \
59 if (IS_ERR(__tmp) || !__tmp) \
63 #define DEBUGFS_ADD_U32(name, parent, ptr, mode) do { \
64 struct dentry *__tmp; \
65 __tmp = debugfs_create_u32(#name, mode, \
67 if (IS_ERR(__tmp) || !__tmp) \
72 #define DEBUGFS_READ_FILE_OPS(name) \
73 static const struct file_operations iwl_dbgfs_##name##_ops = { \
74 .read = iwl_dbgfs_##name##_read, \
75 .open = simple_open, \
76 .llseek = generic_file_llseek, \
79 #define DEBUGFS_WRITE_FILE_OPS(name) \
80 static const struct file_operations iwl_dbgfs_##name##_ops = { \
81 .write = iwl_dbgfs_##name##_write, \
82 .open = simple_open, \
83 .llseek = generic_file_llseek, \
87 #define DEBUGFS_READ_WRITE_FILE_OPS(name) \
88 static const struct file_operations iwl_dbgfs_##name##_ops = { \
89 .write = iwl_dbgfs_##name##_write, \
90 .read = iwl_dbgfs_##name##_read, \
91 .open = simple_open, \
92 .llseek = generic_file_llseek, \
95 static ssize_t iwl_dbgfs_sram_read(struct file *file,
96 char __user *user_buf,
97 size_t count, loff_t *ppos)
103 bool device_format = false;
108 struct iwl_priv *priv = file->private_data;
109 const struct fw_img *img;
112 if (!iwl_is_ready_rf(priv))
115 /* default is to dump the entire data segment */
116 if (!priv->dbgfs_sram_offset && !priv->dbgfs_sram_len) {
117 priv->dbgfs_sram_offset = 0x800000;
118 if (!priv->ucode_loaded)
120 img = &priv->fw->img[priv->cur_ucode];
121 priv->dbgfs_sram_len = img->sec[IWL_UCODE_SECTION_DATA].len;
123 len = priv->dbgfs_sram_len;
126 device_format = true;
130 bufsz = 50 + len * 4;
131 buf = kmalloc(bufsz, GFP_KERNEL);
135 pos += scnprintf(buf + pos, bufsz - pos, "sram_len: 0x%x\n",
137 pos += scnprintf(buf + pos, bufsz - pos, "sram_offset: 0x%x\n",
138 priv->dbgfs_sram_offset);
140 /* adjust sram address since reads are only on even u32 boundaries */
141 offset = priv->dbgfs_sram_offset & 0x3;
142 sram = priv->dbgfs_sram_offset & ~0x3;
144 /* read the first u32 from sram */
145 val = iwl_trans_read_mem32(priv->trans, sram);
148 /* put the address at the start of every line */
150 pos += scnprintf(buf + pos, bufsz - pos,
151 "%08X: ", sram + offset);
154 pos += scnprintf(buf + pos, bufsz - pos,
155 "%02x", (val >> (8 * (3 - offset))) & 0xff);
157 pos += scnprintf(buf + pos, bufsz - pos,
158 "%02x ", (val >> (8 * offset)) & 0xff);
160 /* if all bytes processed, read the next u32 from sram */
164 val = iwl_trans_read_mem32(priv->trans, sram);
167 /* put in extra spaces and split lines for human readability */
170 pos += scnprintf(buf + pos, bufsz - pos, "\n");
171 } else if (!(i & 7)) {
172 pos += scnprintf(buf + pos, bufsz - pos, " ");
173 } else if (!(i & 3)) {
174 pos += scnprintf(buf + pos, bufsz - pos, " ");
178 pos += scnprintf(buf + pos, bufsz - pos, "\n");
180 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
185 static ssize_t iwl_dbgfs_sram_write(struct file *file,
186 const char __user *user_buf,
187 size_t count, loff_t *ppos)
189 struct iwl_priv *priv = file->private_data;
194 memset(buf, 0, sizeof(buf));
195 buf_size = min(count, sizeof(buf) - 1);
196 if (copy_from_user(buf, user_buf, buf_size))
199 if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
200 priv->dbgfs_sram_offset = offset;
201 priv->dbgfs_sram_len = len;
202 } else if (sscanf(buf, "%x", &offset) == 1) {
203 priv->dbgfs_sram_offset = offset;
204 priv->dbgfs_sram_len = -4;
206 priv->dbgfs_sram_offset = 0;
207 priv->dbgfs_sram_len = 0;
213 static ssize_t iwl_dbgfs_wowlan_sram_read(struct file *file,
214 char __user *user_buf,
215 size_t count, loff_t *ppos)
217 struct iwl_priv *priv = file->private_data;
218 const struct fw_img *img = &priv->fw->img[IWL_UCODE_WOWLAN];
220 if (!priv->wowlan_sram)
223 return simple_read_from_buffer(user_buf, count, ppos,
225 img->sec[IWL_UCODE_SECTION_DATA].len);
227 static ssize_t iwl_dbgfs_stations_read(struct file *file, char __user *user_buf,
228 size_t count, loff_t *ppos)
230 struct iwl_priv *priv = file->private_data;
231 struct iwl_station_entry *station;
232 struct iwl_tid_data *tid_data;
236 /* Add 30 for initial string */
237 const size_t bufsz = 30 + sizeof(char) * 500 * (priv->num_stations);
239 buf = kmalloc(bufsz, GFP_KERNEL);
243 pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
246 for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
247 station = &priv->stations[i];
250 pos += scnprintf(buf + pos, bufsz - pos,
251 "station %d - addr: %pM, flags: %#x\n",
252 i, station->sta.sta.addr,
253 station->sta.station_flags_msk);
254 pos += scnprintf(buf + pos, bufsz - pos,
255 "TID seqno next_rclmd "
256 "rate_n_flags state txq\n");
258 for (j = 0; j < IWL_MAX_TID_COUNT; j++) {
259 tid_data = &priv->tid_data[i][j];
260 pos += scnprintf(buf + pos, bufsz - pos,
261 "%d: 0x%.4x 0x%.4x 0x%.8x "
263 j, tid_data->seq_number,
264 tid_data->next_reclaimed,
265 tid_data->agg.rate_n_flags,
267 tid_data->agg.txq_id);
269 if (tid_data->agg.wait_for_ba)
270 pos += scnprintf(buf + pos, bufsz - pos,
272 pos += scnprintf(buf + pos, bufsz - pos, "\n");
275 pos += scnprintf(buf + pos, bufsz - pos, "\n");
278 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
283 static ssize_t iwl_dbgfs_nvm_read(struct file *file,
284 char __user *user_buf,
289 struct iwl_priv *priv = file->private_data;
290 int pos = 0, ofs = 0, buf_size = 0;
294 size_t eeprom_len = priv->eeprom_blob_size;
295 buf_size = 4 * eeprom_len + 256;
300 ptr = priv->eeprom_blob;
304 /* 4 characters for byte 0xYY */
305 buf = kzalloc(buf_size, GFP_KERNEL);
309 nvm_ver = priv->nvm_data->nvm_version;
310 pos += scnprintf(buf + pos, buf_size - pos,
311 "NVM version: 0x%x\n", nvm_ver);
312 for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
313 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x %16ph\n",
317 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
322 static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
323 size_t count, loff_t *ppos)
325 struct iwl_priv *priv = file->private_data;
326 struct ieee80211_channel *channels = NULL;
327 const struct ieee80211_supported_band *supp_band = NULL;
328 int pos = 0, i, bufsz = PAGE_SIZE;
332 buf = kzalloc(bufsz, GFP_KERNEL);
336 supp_band = iwl_get_hw_mode(priv, NL80211_BAND_2GHZ);
338 channels = supp_band->channels;
340 pos += scnprintf(buf + pos, bufsz - pos,
341 "Displaying %d channels in 2.4GHz band 802.11bg):\n",
342 supp_band->n_channels);
344 for (i = 0; i < supp_band->n_channels; i++)
345 pos += scnprintf(buf + pos, bufsz - pos,
346 "%d: %ddBm: BSS%s%s, %s.\n",
347 channels[i].hw_value,
348 channels[i].max_power,
349 channels[i].flags & IEEE80211_CHAN_RADAR ?
350 " (IEEE 802.11h required)" : "",
351 ((channels[i].flags & IEEE80211_CHAN_NO_IR)
352 || (channels[i].flags &
353 IEEE80211_CHAN_RADAR)) ? "" :
356 IEEE80211_CHAN_NO_IR ?
357 "passive only" : "active/passive");
359 supp_band = iwl_get_hw_mode(priv, NL80211_BAND_5GHZ);
361 channels = supp_band->channels;
363 pos += scnprintf(buf + pos, bufsz - pos,
364 "Displaying %d channels in 5.2GHz band (802.11a)\n",
365 supp_band->n_channels);
367 for (i = 0; i < supp_band->n_channels; i++)
368 pos += scnprintf(buf + pos, bufsz - pos,
369 "%d: %ddBm: BSS%s%s, %s.\n",
370 channels[i].hw_value,
371 channels[i].max_power,
372 channels[i].flags & IEEE80211_CHAN_RADAR ?
373 " (IEEE 802.11h required)" : "",
374 ((channels[i].flags & IEEE80211_CHAN_NO_IR)
375 || (channels[i].flags &
376 IEEE80211_CHAN_RADAR)) ? "" :
379 IEEE80211_CHAN_NO_IR ?
380 "passive only" : "active/passive");
382 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
387 static ssize_t iwl_dbgfs_status_read(struct file *file,
388 char __user *user_buf,
389 size_t count, loff_t *ppos) {
391 struct iwl_priv *priv = file->private_data;
394 const size_t bufsz = sizeof(buf);
396 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_RF_KILL_HW:\t %d\n",
397 test_bit(STATUS_RF_KILL_HW, &priv->status));
398 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_CT_KILL:\t\t %d\n",
399 test_bit(STATUS_CT_KILL, &priv->status));
400 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_ALIVE:\t\t %d\n",
401 test_bit(STATUS_ALIVE, &priv->status));
402 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_READY:\t\t %d\n",
403 test_bit(STATUS_READY, &priv->status));
404 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_EXIT_PENDING:\t %d\n",
405 test_bit(STATUS_EXIT_PENDING, &priv->status));
406 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_STATISTICS:\t %d\n",
407 test_bit(STATUS_STATISTICS, &priv->status));
408 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCANNING:\t %d\n",
409 test_bit(STATUS_SCANNING, &priv->status));
410 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_ABORTING:\t %d\n",
411 test_bit(STATUS_SCAN_ABORTING, &priv->status));
412 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_HW:\t\t %d\n",
413 test_bit(STATUS_SCAN_HW, &priv->status));
414 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_POWER_PMI:\t %d\n",
415 test_bit(STATUS_POWER_PMI, &priv->status));
416 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_FW_ERROR:\t %d\n",
417 test_bit(STATUS_FW_ERROR, &priv->status));
418 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
421 static ssize_t iwl_dbgfs_rx_handlers_read(struct file *file,
422 char __user *user_buf,
423 size_t count, loff_t *ppos) {
425 struct iwl_priv *priv = file->private_data;
430 int bufsz = 24 * 64; /* 24 items * 64 char per item */
433 buf = kzalloc(bufsz, GFP_KERNEL);
437 for (cnt = 0; cnt < REPLY_MAX; cnt++) {
438 if (priv->rx_handlers_stats[cnt] > 0)
439 pos += scnprintf(buf + pos, bufsz - pos,
440 "\tRx handler[%36s]:\t\t %u\n",
441 iwl_get_cmd_string(priv->trans, (u32)cnt),
442 priv->rx_handlers_stats[cnt]);
445 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
450 static ssize_t iwl_dbgfs_rx_handlers_write(struct file *file,
451 const char __user *user_buf,
452 size_t count, loff_t *ppos)
454 struct iwl_priv *priv = file->private_data;
460 memset(buf, 0, sizeof(buf));
461 buf_size = min(count, sizeof(buf) - 1);
462 if (copy_from_user(buf, user_buf, buf_size))
464 if (sscanf(buf, "%x", &reset_flag) != 1)
467 memset(&priv->rx_handlers_stats[0], 0,
468 sizeof(priv->rx_handlers_stats));
473 static ssize_t iwl_dbgfs_qos_read(struct file *file, char __user *user_buf,
474 size_t count, loff_t *ppos)
476 struct iwl_priv *priv = file->private_data;
477 struct iwl_rxon_context *ctx;
479 char buf[256 * NUM_IWL_RXON_CTX];
480 const size_t bufsz = sizeof(buf);
482 for_each_context(priv, ctx) {
483 pos += scnprintf(buf + pos, bufsz - pos, "context %d:\n",
485 for (i = 0; i < AC_NUM; i++) {
486 pos += scnprintf(buf + pos, bufsz - pos,
487 "\tcw_min\tcw_max\taifsn\ttxop\n");
488 pos += scnprintf(buf + pos, bufsz - pos,
489 "AC[%d]\t%u\t%u\t%u\t%u\n", i,
490 ctx->qos_data.def_qos_parm.ac[i].cw_min,
491 ctx->qos_data.def_qos_parm.ac[i].cw_max,
492 ctx->qos_data.def_qos_parm.ac[i].aifsn,
493 ctx->qos_data.def_qos_parm.ac[i].edca_txop);
495 pos += scnprintf(buf + pos, bufsz - pos, "\n");
497 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
500 static ssize_t iwl_dbgfs_thermal_throttling_read(struct file *file,
501 char __user *user_buf,
502 size_t count, loff_t *ppos)
504 struct iwl_priv *priv = file->private_data;
505 struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
506 struct iwl_tt_restriction *restriction;
509 const size_t bufsz = sizeof(buf);
511 pos += scnprintf(buf + pos, bufsz - pos,
512 "Thermal Throttling Mode: %s\n",
513 tt->advanced_tt ? "Advance" : "Legacy");
514 pos += scnprintf(buf + pos, bufsz - pos,
515 "Thermal Throttling State: %d\n",
517 if (tt->advanced_tt) {
518 restriction = tt->restriction + tt->state;
519 pos += scnprintf(buf + pos, bufsz - pos,
521 restriction->tx_stream);
522 pos += scnprintf(buf + pos, bufsz - pos,
524 restriction->rx_stream);
525 pos += scnprintf(buf + pos, bufsz - pos,
529 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
532 static ssize_t iwl_dbgfs_disable_ht40_write(struct file *file,
533 const char __user *user_buf,
534 size_t count, loff_t *ppos)
536 struct iwl_priv *priv = file->private_data;
541 memset(buf, 0, sizeof(buf));
542 buf_size = min(count, sizeof(buf) - 1);
543 if (copy_from_user(buf, user_buf, buf_size))
545 if (sscanf(buf, "%d", &ht40) != 1)
547 if (!iwl_is_any_associated(priv))
548 priv->disable_ht40 = ht40 ? true : false;
555 static ssize_t iwl_dbgfs_disable_ht40_read(struct file *file,
556 char __user *user_buf,
557 size_t count, loff_t *ppos)
559 struct iwl_priv *priv = file->private_data;
562 const size_t bufsz = sizeof(buf);
564 pos += scnprintf(buf + pos, bufsz - pos,
565 "11n 40MHz Mode: %s\n",
566 priv->disable_ht40 ? "Disabled" : "Enabled");
567 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
570 static ssize_t iwl_dbgfs_temperature_read(struct file *file,
571 char __user *user_buf,
572 size_t count, loff_t *ppos)
574 struct iwl_priv *priv = file->private_data;
577 const size_t bufsz = sizeof(buf);
579 pos += scnprintf(buf + pos, bufsz - pos, "%d\n", priv->temperature);
580 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
584 static ssize_t iwl_dbgfs_sleep_level_override_write(struct file *file,
585 const char __user *user_buf,
586 size_t count, loff_t *ppos)
588 struct iwl_priv *priv = file->private_data;
593 memset(buf, 0, sizeof(buf));
594 buf_size = min(count, sizeof(buf) - 1);
595 if (copy_from_user(buf, user_buf, buf_size))
598 if (sscanf(buf, "%d", &value) != 1)
602 * Our users expect 0 to be "CAM", but 0 isn't actually
603 * valid here. However, let's not confuse them and present
604 * IWL_POWER_INDEX_1 as "1", not "0".
611 if (value != -1 && (value < 0 || value >= IWL_POWER_NUM))
614 if (!iwl_is_ready_rf(priv))
617 priv->power_data.debug_sleep_level_override = value;
619 mutex_lock(&priv->mutex);
620 iwl_power_update_mode(priv, true);
621 mutex_unlock(&priv->mutex);
626 static ssize_t iwl_dbgfs_sleep_level_override_read(struct file *file,
627 char __user *user_buf,
628 size_t count, loff_t *ppos)
630 struct iwl_priv *priv = file->private_data;
633 const size_t bufsz = sizeof(buf);
635 /* see the write function */
636 value = priv->power_data.debug_sleep_level_override;
640 pos = scnprintf(buf, bufsz, "%d\n", value);
641 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
644 static ssize_t iwl_dbgfs_current_sleep_command_read(struct file *file,
645 char __user *user_buf,
646 size_t count, loff_t *ppos)
648 struct iwl_priv *priv = file->private_data;
651 const size_t bufsz = sizeof(buf);
652 struct iwl_powertable_cmd *cmd = &priv->power_data.sleep_cmd;
654 pos += scnprintf(buf + pos, bufsz - pos,
655 "flags: %#.2x\n", le16_to_cpu(cmd->flags));
656 pos += scnprintf(buf + pos, bufsz - pos,
657 "RX/TX timeout: %d/%d usec\n",
658 le32_to_cpu(cmd->rx_data_timeout),
659 le32_to_cpu(cmd->tx_data_timeout));
660 for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
661 pos += scnprintf(buf + pos, bufsz - pos,
662 "sleep_interval[%d]: %d\n", i,
663 le32_to_cpu(cmd->sleep_interval[i]));
665 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
668 DEBUGFS_READ_WRITE_FILE_OPS(sram);
669 DEBUGFS_READ_FILE_OPS(wowlan_sram);
670 DEBUGFS_READ_FILE_OPS(nvm);
671 DEBUGFS_READ_FILE_OPS(stations);
672 DEBUGFS_READ_FILE_OPS(channels);
673 DEBUGFS_READ_FILE_OPS(status);
674 DEBUGFS_READ_WRITE_FILE_OPS(rx_handlers);
675 DEBUGFS_READ_FILE_OPS(qos);
676 DEBUGFS_READ_FILE_OPS(thermal_throttling);
677 DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40);
678 DEBUGFS_READ_FILE_OPS(temperature);
679 DEBUGFS_READ_WRITE_FILE_OPS(sleep_level_override);
680 DEBUGFS_READ_FILE_OPS(current_sleep_command);
682 #define fmt_value " %-30s %10u\n"
683 #define fmt_hex " %-30s 0x%02X\n"
684 #define fmt_table " %-30s %10u %10u %10u %10u\n"
685 #define fmt_header "%-32s current cumulative delta max\n"
687 static int iwl_statistics_flag(struct iwl_priv *priv, char *buf, int bufsz)
692 lockdep_assert_held(&priv->statistics.lock);
694 flag = le32_to_cpu(priv->statistics.flag);
696 p += scnprintf(buf + p, bufsz - p, "Statistics Flag(0x%X):\n", flag);
697 if (flag & UCODE_STATISTICS_CLEAR_MSK)
698 p += scnprintf(buf + p, bufsz - p,
699 "\tStatistics have been cleared\n");
700 p += scnprintf(buf + p, bufsz - p, "\tOperational Frequency: %s\n",
701 (flag & UCODE_STATISTICS_FREQUENCY_MSK)
702 ? "2.4 GHz" : "5.2 GHz");
703 p += scnprintf(buf + p, bufsz - p, "\tTGj Narrow Band: %s\n",
704 (flag & UCODE_STATISTICS_NARROW_BAND_MSK)
705 ? "enabled" : "disabled");
710 static ssize_t iwl_dbgfs_ucode_rx_stats_read(struct file *file,
711 char __user *user_buf,
712 size_t count, loff_t *ppos)
714 struct iwl_priv *priv = file->private_data;
717 int bufsz = sizeof(struct statistics_rx_phy) * 40 +
718 sizeof(struct statistics_rx_non_phy) * 40 +
719 sizeof(struct statistics_rx_ht_phy) * 40 + 400;
721 struct statistics_rx_phy *ofdm, *accum_ofdm, *delta_ofdm, *max_ofdm;
722 struct statistics_rx_phy *cck, *accum_cck, *delta_cck, *max_cck;
723 struct statistics_rx_non_phy *general, *accum_general;
724 struct statistics_rx_non_phy *delta_general, *max_general;
725 struct statistics_rx_ht_phy *ht, *accum_ht, *delta_ht, *max_ht;
727 if (!iwl_is_alive(priv))
730 buf = kzalloc(bufsz, GFP_KERNEL);
735 * the statistic information display here is based on
736 * the last statistics notification from uCode
737 * might not reflect the current uCode activity
739 spin_lock_bh(&priv->statistics.lock);
740 ofdm = &priv->statistics.rx_ofdm;
741 cck = &priv->statistics.rx_cck;
742 general = &priv->statistics.rx_non_phy;
743 ht = &priv->statistics.rx_ofdm_ht;
744 accum_ofdm = &priv->accum_stats.rx_ofdm;
745 accum_cck = &priv->accum_stats.rx_cck;
746 accum_general = &priv->accum_stats.rx_non_phy;
747 accum_ht = &priv->accum_stats.rx_ofdm_ht;
748 delta_ofdm = &priv->delta_stats.rx_ofdm;
749 delta_cck = &priv->delta_stats.rx_cck;
750 delta_general = &priv->delta_stats.rx_non_phy;
751 delta_ht = &priv->delta_stats.rx_ofdm_ht;
752 max_ofdm = &priv->max_delta_stats.rx_ofdm;
753 max_cck = &priv->max_delta_stats.rx_cck;
754 max_general = &priv->max_delta_stats.rx_non_phy;
755 max_ht = &priv->max_delta_stats.rx_ofdm_ht;
757 pos += iwl_statistics_flag(priv, buf, bufsz);
758 pos += scnprintf(buf + pos, bufsz - pos,
759 fmt_header, "Statistics_Rx - OFDM:");
760 pos += scnprintf(buf + pos, bufsz - pos,
761 fmt_table, "ina_cnt:",
762 le32_to_cpu(ofdm->ina_cnt),
764 delta_ofdm->ina_cnt, max_ofdm->ina_cnt);
765 pos += scnprintf(buf + pos, bufsz - pos,
766 fmt_table, "fina_cnt:",
767 le32_to_cpu(ofdm->fina_cnt), accum_ofdm->fina_cnt,
768 delta_ofdm->fina_cnt, max_ofdm->fina_cnt);
769 pos += scnprintf(buf + pos, bufsz - pos,
770 fmt_table, "plcp_err:",
771 le32_to_cpu(ofdm->plcp_err), accum_ofdm->plcp_err,
772 delta_ofdm->plcp_err, max_ofdm->plcp_err);
773 pos += scnprintf(buf + pos, bufsz - pos,
774 fmt_table, "crc32_err:",
775 le32_to_cpu(ofdm->crc32_err), accum_ofdm->crc32_err,
776 delta_ofdm->crc32_err, max_ofdm->crc32_err);
777 pos += scnprintf(buf + pos, bufsz - pos,
778 fmt_table, "overrun_err:",
779 le32_to_cpu(ofdm->overrun_err),
780 accum_ofdm->overrun_err, delta_ofdm->overrun_err,
781 max_ofdm->overrun_err);
782 pos += scnprintf(buf + pos, bufsz - pos,
783 fmt_table, "early_overrun_err:",
784 le32_to_cpu(ofdm->early_overrun_err),
785 accum_ofdm->early_overrun_err,
786 delta_ofdm->early_overrun_err,
787 max_ofdm->early_overrun_err);
788 pos += scnprintf(buf + pos, bufsz - pos,
789 fmt_table, "crc32_good:",
790 le32_to_cpu(ofdm->crc32_good),
791 accum_ofdm->crc32_good, delta_ofdm->crc32_good,
792 max_ofdm->crc32_good);
793 pos += scnprintf(buf + pos, bufsz - pos,
794 fmt_table, "false_alarm_cnt:",
795 le32_to_cpu(ofdm->false_alarm_cnt),
796 accum_ofdm->false_alarm_cnt,
797 delta_ofdm->false_alarm_cnt,
798 max_ofdm->false_alarm_cnt);
799 pos += scnprintf(buf + pos, bufsz - pos,
800 fmt_table, "fina_sync_err_cnt:",
801 le32_to_cpu(ofdm->fina_sync_err_cnt),
802 accum_ofdm->fina_sync_err_cnt,
803 delta_ofdm->fina_sync_err_cnt,
804 max_ofdm->fina_sync_err_cnt);
805 pos += scnprintf(buf + pos, bufsz - pos,
806 fmt_table, "sfd_timeout:",
807 le32_to_cpu(ofdm->sfd_timeout),
808 accum_ofdm->sfd_timeout, delta_ofdm->sfd_timeout,
809 max_ofdm->sfd_timeout);
810 pos += scnprintf(buf + pos, bufsz - pos,
811 fmt_table, "fina_timeout:",
812 le32_to_cpu(ofdm->fina_timeout),
813 accum_ofdm->fina_timeout, delta_ofdm->fina_timeout,
814 max_ofdm->fina_timeout);
815 pos += scnprintf(buf + pos, bufsz - pos,
816 fmt_table, "unresponded_rts:",
817 le32_to_cpu(ofdm->unresponded_rts),
818 accum_ofdm->unresponded_rts,
819 delta_ofdm->unresponded_rts,
820 max_ofdm->unresponded_rts);
821 pos += scnprintf(buf + pos, bufsz - pos,
822 fmt_table, "rxe_frame_lmt_ovrun:",
823 le32_to_cpu(ofdm->rxe_frame_limit_overrun),
824 accum_ofdm->rxe_frame_limit_overrun,
825 delta_ofdm->rxe_frame_limit_overrun,
826 max_ofdm->rxe_frame_limit_overrun);
827 pos += scnprintf(buf + pos, bufsz - pos,
828 fmt_table, "sent_ack_cnt:",
829 le32_to_cpu(ofdm->sent_ack_cnt),
830 accum_ofdm->sent_ack_cnt, delta_ofdm->sent_ack_cnt,
831 max_ofdm->sent_ack_cnt);
832 pos += scnprintf(buf + pos, bufsz - pos,
833 fmt_table, "sent_cts_cnt:",
834 le32_to_cpu(ofdm->sent_cts_cnt),
835 accum_ofdm->sent_cts_cnt, delta_ofdm->sent_cts_cnt,
836 max_ofdm->sent_cts_cnt);
837 pos += scnprintf(buf + pos, bufsz - pos,
838 fmt_table, "sent_ba_rsp_cnt:",
839 le32_to_cpu(ofdm->sent_ba_rsp_cnt),
840 accum_ofdm->sent_ba_rsp_cnt,
841 delta_ofdm->sent_ba_rsp_cnt,
842 max_ofdm->sent_ba_rsp_cnt);
843 pos += scnprintf(buf + pos, bufsz - pos,
844 fmt_table, "dsp_self_kill:",
845 le32_to_cpu(ofdm->dsp_self_kill),
846 accum_ofdm->dsp_self_kill,
847 delta_ofdm->dsp_self_kill,
848 max_ofdm->dsp_self_kill);
849 pos += scnprintf(buf + pos, bufsz - pos,
850 fmt_table, "mh_format_err:",
851 le32_to_cpu(ofdm->mh_format_err),
852 accum_ofdm->mh_format_err,
853 delta_ofdm->mh_format_err,
854 max_ofdm->mh_format_err);
855 pos += scnprintf(buf + pos, bufsz - pos,
856 fmt_table, "re_acq_main_rssi_sum:",
857 le32_to_cpu(ofdm->re_acq_main_rssi_sum),
858 accum_ofdm->re_acq_main_rssi_sum,
859 delta_ofdm->re_acq_main_rssi_sum,
860 max_ofdm->re_acq_main_rssi_sum);
862 pos += scnprintf(buf + pos, bufsz - pos,
863 fmt_header, "Statistics_Rx - CCK:");
864 pos += scnprintf(buf + pos, bufsz - pos,
865 fmt_table, "ina_cnt:",
866 le32_to_cpu(cck->ina_cnt), accum_cck->ina_cnt,
867 delta_cck->ina_cnt, max_cck->ina_cnt);
868 pos += scnprintf(buf + pos, bufsz - pos,
869 fmt_table, "fina_cnt:",
870 le32_to_cpu(cck->fina_cnt), accum_cck->fina_cnt,
871 delta_cck->fina_cnt, max_cck->fina_cnt);
872 pos += scnprintf(buf + pos, bufsz - pos,
873 fmt_table, "plcp_err:",
874 le32_to_cpu(cck->plcp_err), accum_cck->plcp_err,
875 delta_cck->plcp_err, max_cck->plcp_err);
876 pos += scnprintf(buf + pos, bufsz - pos,
877 fmt_table, "crc32_err:",
878 le32_to_cpu(cck->crc32_err), accum_cck->crc32_err,
879 delta_cck->crc32_err, max_cck->crc32_err);
880 pos += scnprintf(buf + pos, bufsz - pos,
881 fmt_table, "overrun_err:",
882 le32_to_cpu(cck->overrun_err),
883 accum_cck->overrun_err, delta_cck->overrun_err,
884 max_cck->overrun_err);
885 pos += scnprintf(buf + pos, bufsz - pos,
886 fmt_table, "early_overrun_err:",
887 le32_to_cpu(cck->early_overrun_err),
888 accum_cck->early_overrun_err,
889 delta_cck->early_overrun_err,
890 max_cck->early_overrun_err);
891 pos += scnprintf(buf + pos, bufsz - pos,
892 fmt_table, "crc32_good:",
893 le32_to_cpu(cck->crc32_good), accum_cck->crc32_good,
894 delta_cck->crc32_good, max_cck->crc32_good);
895 pos += scnprintf(buf + pos, bufsz - pos,
896 fmt_table, "false_alarm_cnt:",
897 le32_to_cpu(cck->false_alarm_cnt),
898 accum_cck->false_alarm_cnt,
899 delta_cck->false_alarm_cnt, max_cck->false_alarm_cnt);
900 pos += scnprintf(buf + pos, bufsz - pos,
901 fmt_table, "fina_sync_err_cnt:",
902 le32_to_cpu(cck->fina_sync_err_cnt),
903 accum_cck->fina_sync_err_cnt,
904 delta_cck->fina_sync_err_cnt,
905 max_cck->fina_sync_err_cnt);
906 pos += scnprintf(buf + pos, bufsz - pos,
907 fmt_table, "sfd_timeout:",
908 le32_to_cpu(cck->sfd_timeout),
909 accum_cck->sfd_timeout, delta_cck->sfd_timeout,
910 max_cck->sfd_timeout);
911 pos += scnprintf(buf + pos, bufsz - pos,
912 fmt_table, "fina_timeout:",
913 le32_to_cpu(cck->fina_timeout),
914 accum_cck->fina_timeout, delta_cck->fina_timeout,
915 max_cck->fina_timeout);
916 pos += scnprintf(buf + pos, bufsz - pos,
917 fmt_table, "unresponded_rts:",
918 le32_to_cpu(cck->unresponded_rts),
919 accum_cck->unresponded_rts, delta_cck->unresponded_rts,
920 max_cck->unresponded_rts);
921 pos += scnprintf(buf + pos, bufsz - pos,
922 fmt_table, "rxe_frame_lmt_ovrun:",
923 le32_to_cpu(cck->rxe_frame_limit_overrun),
924 accum_cck->rxe_frame_limit_overrun,
925 delta_cck->rxe_frame_limit_overrun,
926 max_cck->rxe_frame_limit_overrun);
927 pos += scnprintf(buf + pos, bufsz - pos,
928 fmt_table, "sent_ack_cnt:",
929 le32_to_cpu(cck->sent_ack_cnt),
930 accum_cck->sent_ack_cnt, delta_cck->sent_ack_cnt,
931 max_cck->sent_ack_cnt);
932 pos += scnprintf(buf + pos, bufsz - pos,
933 fmt_table, "sent_cts_cnt:",
934 le32_to_cpu(cck->sent_cts_cnt),
935 accum_cck->sent_cts_cnt, delta_cck->sent_cts_cnt,
936 max_cck->sent_cts_cnt);
937 pos += scnprintf(buf + pos, bufsz - pos,
938 fmt_table, "sent_ba_rsp_cnt:",
939 le32_to_cpu(cck->sent_ba_rsp_cnt),
940 accum_cck->sent_ba_rsp_cnt,
941 delta_cck->sent_ba_rsp_cnt,
942 max_cck->sent_ba_rsp_cnt);
943 pos += scnprintf(buf + pos, bufsz - pos,
944 fmt_table, "dsp_self_kill:",
945 le32_to_cpu(cck->dsp_self_kill),
946 accum_cck->dsp_self_kill, delta_cck->dsp_self_kill,
947 max_cck->dsp_self_kill);
948 pos += scnprintf(buf + pos, bufsz - pos,
949 fmt_table, "mh_format_err:",
950 le32_to_cpu(cck->mh_format_err),
951 accum_cck->mh_format_err, delta_cck->mh_format_err,
952 max_cck->mh_format_err);
953 pos += scnprintf(buf + pos, bufsz - pos,
954 fmt_table, "re_acq_main_rssi_sum:",
955 le32_to_cpu(cck->re_acq_main_rssi_sum),
956 accum_cck->re_acq_main_rssi_sum,
957 delta_cck->re_acq_main_rssi_sum,
958 max_cck->re_acq_main_rssi_sum);
960 pos += scnprintf(buf + pos, bufsz - pos,
961 fmt_header, "Statistics_Rx - GENERAL:");
962 pos += scnprintf(buf + pos, bufsz - pos,
963 fmt_table, "bogus_cts:",
964 le32_to_cpu(general->bogus_cts),
965 accum_general->bogus_cts, delta_general->bogus_cts,
966 max_general->bogus_cts);
967 pos += scnprintf(buf + pos, bufsz - pos,
968 fmt_table, "bogus_ack:",
969 le32_to_cpu(general->bogus_ack),
970 accum_general->bogus_ack, delta_general->bogus_ack,
971 max_general->bogus_ack);
972 pos += scnprintf(buf + pos, bufsz - pos,
973 fmt_table, "non_bssid_frames:",
974 le32_to_cpu(general->non_bssid_frames),
975 accum_general->non_bssid_frames,
976 delta_general->non_bssid_frames,
977 max_general->non_bssid_frames);
978 pos += scnprintf(buf + pos, bufsz - pos,
979 fmt_table, "filtered_frames:",
980 le32_to_cpu(general->filtered_frames),
981 accum_general->filtered_frames,
982 delta_general->filtered_frames,
983 max_general->filtered_frames);
984 pos += scnprintf(buf + pos, bufsz - pos,
985 fmt_table, "non_channel_beacons:",
986 le32_to_cpu(general->non_channel_beacons),
987 accum_general->non_channel_beacons,
988 delta_general->non_channel_beacons,
989 max_general->non_channel_beacons);
990 pos += scnprintf(buf + pos, bufsz - pos,
991 fmt_table, "channel_beacons:",
992 le32_to_cpu(general->channel_beacons),
993 accum_general->channel_beacons,
994 delta_general->channel_beacons,
995 max_general->channel_beacons);
996 pos += scnprintf(buf + pos, bufsz - pos,
997 fmt_table, "num_missed_bcon:",
998 le32_to_cpu(general->num_missed_bcon),
999 accum_general->num_missed_bcon,
1000 delta_general->num_missed_bcon,
1001 max_general->num_missed_bcon);
1002 pos += scnprintf(buf + pos, bufsz - pos,
1003 fmt_table, "adc_rx_saturation_time:",
1004 le32_to_cpu(general->adc_rx_saturation_time),
1005 accum_general->adc_rx_saturation_time,
1006 delta_general->adc_rx_saturation_time,
1007 max_general->adc_rx_saturation_time);
1008 pos += scnprintf(buf + pos, bufsz - pos,
1009 fmt_table, "ina_detect_search_tm:",
1010 le32_to_cpu(general->ina_detection_search_time),
1011 accum_general->ina_detection_search_time,
1012 delta_general->ina_detection_search_time,
1013 max_general->ina_detection_search_time);
1014 pos += scnprintf(buf + pos, bufsz - pos,
1015 fmt_table, "beacon_silence_rssi_a:",
1016 le32_to_cpu(general->beacon_silence_rssi_a),
1017 accum_general->beacon_silence_rssi_a,
1018 delta_general->beacon_silence_rssi_a,
1019 max_general->beacon_silence_rssi_a);
1020 pos += scnprintf(buf + pos, bufsz - pos,
1021 fmt_table, "beacon_silence_rssi_b:",
1022 le32_to_cpu(general->beacon_silence_rssi_b),
1023 accum_general->beacon_silence_rssi_b,
1024 delta_general->beacon_silence_rssi_b,
1025 max_general->beacon_silence_rssi_b);
1026 pos += scnprintf(buf + pos, bufsz - pos,
1027 fmt_table, "beacon_silence_rssi_c:",
1028 le32_to_cpu(general->beacon_silence_rssi_c),
1029 accum_general->beacon_silence_rssi_c,
1030 delta_general->beacon_silence_rssi_c,
1031 max_general->beacon_silence_rssi_c);
1032 pos += scnprintf(buf + pos, bufsz - pos,
1033 fmt_table, "interference_data_flag:",
1034 le32_to_cpu(general->interference_data_flag),
1035 accum_general->interference_data_flag,
1036 delta_general->interference_data_flag,
1037 max_general->interference_data_flag);
1038 pos += scnprintf(buf + pos, bufsz - pos,
1039 fmt_table, "channel_load:",
1040 le32_to_cpu(general->channel_load),
1041 accum_general->channel_load,
1042 delta_general->channel_load,
1043 max_general->channel_load);
1044 pos += scnprintf(buf + pos, bufsz - pos,
1045 fmt_table, "dsp_false_alarms:",
1046 le32_to_cpu(general->dsp_false_alarms),
1047 accum_general->dsp_false_alarms,
1048 delta_general->dsp_false_alarms,
1049 max_general->dsp_false_alarms);
1050 pos += scnprintf(buf + pos, bufsz - pos,
1051 fmt_table, "beacon_rssi_a:",
1052 le32_to_cpu(general->beacon_rssi_a),
1053 accum_general->beacon_rssi_a,
1054 delta_general->beacon_rssi_a,
1055 max_general->beacon_rssi_a);
1056 pos += scnprintf(buf + pos, bufsz - pos,
1057 fmt_table, "beacon_rssi_b:",
1058 le32_to_cpu(general->beacon_rssi_b),
1059 accum_general->beacon_rssi_b,
1060 delta_general->beacon_rssi_b,
1061 max_general->beacon_rssi_b);
1062 pos += scnprintf(buf + pos, bufsz - pos,
1063 fmt_table, "beacon_rssi_c:",
1064 le32_to_cpu(general->beacon_rssi_c),
1065 accum_general->beacon_rssi_c,
1066 delta_general->beacon_rssi_c,
1067 max_general->beacon_rssi_c);
1068 pos += scnprintf(buf + pos, bufsz - pos,
1069 fmt_table, "beacon_energy_a:",
1070 le32_to_cpu(general->beacon_energy_a),
1071 accum_general->beacon_energy_a,
1072 delta_general->beacon_energy_a,
1073 max_general->beacon_energy_a);
1074 pos += scnprintf(buf + pos, bufsz - pos,
1075 fmt_table, "beacon_energy_b:",
1076 le32_to_cpu(general->beacon_energy_b),
1077 accum_general->beacon_energy_b,
1078 delta_general->beacon_energy_b,
1079 max_general->beacon_energy_b);
1080 pos += scnprintf(buf + pos, bufsz - pos,
1081 fmt_table, "beacon_energy_c:",
1082 le32_to_cpu(general->beacon_energy_c),
1083 accum_general->beacon_energy_c,
1084 delta_general->beacon_energy_c,
1085 max_general->beacon_energy_c);
1087 pos += scnprintf(buf + pos, bufsz - pos,
1088 fmt_header, "Statistics_Rx - OFDM_HT:");
1089 pos += scnprintf(buf + pos, bufsz - pos,
1090 fmt_table, "plcp_err:",
1091 le32_to_cpu(ht->plcp_err), accum_ht->plcp_err,
1092 delta_ht->plcp_err, max_ht->plcp_err);
1093 pos += scnprintf(buf + pos, bufsz - pos,
1094 fmt_table, "overrun_err:",
1095 le32_to_cpu(ht->overrun_err), accum_ht->overrun_err,
1096 delta_ht->overrun_err, max_ht->overrun_err);
1097 pos += scnprintf(buf + pos, bufsz - pos,
1098 fmt_table, "early_overrun_err:",
1099 le32_to_cpu(ht->early_overrun_err),
1100 accum_ht->early_overrun_err,
1101 delta_ht->early_overrun_err,
1102 max_ht->early_overrun_err);
1103 pos += scnprintf(buf + pos, bufsz - pos,
1104 fmt_table, "crc32_good:",
1105 le32_to_cpu(ht->crc32_good), accum_ht->crc32_good,
1106 delta_ht->crc32_good, max_ht->crc32_good);
1107 pos += scnprintf(buf + pos, bufsz - pos,
1108 fmt_table, "crc32_err:",
1109 le32_to_cpu(ht->crc32_err), accum_ht->crc32_err,
1110 delta_ht->crc32_err, max_ht->crc32_err);
1111 pos += scnprintf(buf + pos, bufsz - pos,
1112 fmt_table, "mh_format_err:",
1113 le32_to_cpu(ht->mh_format_err),
1114 accum_ht->mh_format_err,
1115 delta_ht->mh_format_err, max_ht->mh_format_err);
1116 pos += scnprintf(buf + pos, bufsz - pos,
1117 fmt_table, "agg_crc32_good:",
1118 le32_to_cpu(ht->agg_crc32_good),
1119 accum_ht->agg_crc32_good,
1120 delta_ht->agg_crc32_good, max_ht->agg_crc32_good);
1121 pos += scnprintf(buf + pos, bufsz - pos,
1122 fmt_table, "agg_mpdu_cnt:",
1123 le32_to_cpu(ht->agg_mpdu_cnt),
1124 accum_ht->agg_mpdu_cnt,
1125 delta_ht->agg_mpdu_cnt, max_ht->agg_mpdu_cnt);
1126 pos += scnprintf(buf + pos, bufsz - pos,
1127 fmt_table, "agg_cnt:",
1128 le32_to_cpu(ht->agg_cnt), accum_ht->agg_cnt,
1129 delta_ht->agg_cnt, max_ht->agg_cnt);
1130 pos += scnprintf(buf + pos, bufsz - pos,
1131 fmt_table, "unsupport_mcs:",
1132 le32_to_cpu(ht->unsupport_mcs),
1133 accum_ht->unsupport_mcs,
1134 delta_ht->unsupport_mcs, max_ht->unsupport_mcs);
1136 spin_unlock_bh(&priv->statistics.lock);
1138 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1143 static ssize_t iwl_dbgfs_ucode_tx_stats_read(struct file *file,
1144 char __user *user_buf,
1145 size_t count, loff_t *ppos)
1147 struct iwl_priv *priv = file->private_data;
1150 int bufsz = (sizeof(struct statistics_tx) * 48) + 250;
1152 struct statistics_tx *tx, *accum_tx, *delta_tx, *max_tx;
1154 if (!iwl_is_alive(priv))
1157 buf = kzalloc(bufsz, GFP_KERNEL);
1161 /* the statistic information display here is based on
1162 * the last statistics notification from uCode
1163 * might not reflect the current uCode activity
1165 spin_lock_bh(&priv->statistics.lock);
1167 tx = &priv->statistics.tx;
1168 accum_tx = &priv->accum_stats.tx;
1169 delta_tx = &priv->delta_stats.tx;
1170 max_tx = &priv->max_delta_stats.tx;
1172 pos += iwl_statistics_flag(priv, buf, bufsz);
1173 pos += scnprintf(buf + pos, bufsz - pos,
1174 fmt_header, "Statistics_Tx:");
1175 pos += scnprintf(buf + pos, bufsz - pos,
1176 fmt_table, "preamble:",
1177 le32_to_cpu(tx->preamble_cnt),
1178 accum_tx->preamble_cnt,
1179 delta_tx->preamble_cnt, max_tx->preamble_cnt);
1180 pos += scnprintf(buf + pos, bufsz - pos,
1181 fmt_table, "rx_detected_cnt:",
1182 le32_to_cpu(tx->rx_detected_cnt),
1183 accum_tx->rx_detected_cnt,
1184 delta_tx->rx_detected_cnt, max_tx->rx_detected_cnt);
1185 pos += scnprintf(buf + pos, bufsz - pos,
1186 fmt_table, "bt_prio_defer_cnt:",
1187 le32_to_cpu(tx->bt_prio_defer_cnt),
1188 accum_tx->bt_prio_defer_cnt,
1189 delta_tx->bt_prio_defer_cnt,
1190 max_tx->bt_prio_defer_cnt);
1191 pos += scnprintf(buf + pos, bufsz - pos,
1192 fmt_table, "bt_prio_kill_cnt:",
1193 le32_to_cpu(tx->bt_prio_kill_cnt),
1194 accum_tx->bt_prio_kill_cnt,
1195 delta_tx->bt_prio_kill_cnt,
1196 max_tx->bt_prio_kill_cnt);
1197 pos += scnprintf(buf + pos, bufsz - pos,
1198 fmt_table, "few_bytes_cnt:",
1199 le32_to_cpu(tx->few_bytes_cnt),
1200 accum_tx->few_bytes_cnt,
1201 delta_tx->few_bytes_cnt, max_tx->few_bytes_cnt);
1202 pos += scnprintf(buf + pos, bufsz - pos,
1203 fmt_table, "cts_timeout:",
1204 le32_to_cpu(tx->cts_timeout), accum_tx->cts_timeout,
1205 delta_tx->cts_timeout, max_tx->cts_timeout);
1206 pos += scnprintf(buf + pos, bufsz - pos,
1207 fmt_table, "ack_timeout:",
1208 le32_to_cpu(tx->ack_timeout),
1209 accum_tx->ack_timeout,
1210 delta_tx->ack_timeout, max_tx->ack_timeout);
1211 pos += scnprintf(buf + pos, bufsz - pos,
1212 fmt_table, "expected_ack_cnt:",
1213 le32_to_cpu(tx->expected_ack_cnt),
1214 accum_tx->expected_ack_cnt,
1215 delta_tx->expected_ack_cnt,
1216 max_tx->expected_ack_cnt);
1217 pos += scnprintf(buf + pos, bufsz - pos,
1218 fmt_table, "actual_ack_cnt:",
1219 le32_to_cpu(tx->actual_ack_cnt),
1220 accum_tx->actual_ack_cnt,
1221 delta_tx->actual_ack_cnt,
1222 max_tx->actual_ack_cnt);
1223 pos += scnprintf(buf + pos, bufsz - pos,
1224 fmt_table, "dump_msdu_cnt:",
1225 le32_to_cpu(tx->dump_msdu_cnt),
1226 accum_tx->dump_msdu_cnt,
1227 delta_tx->dump_msdu_cnt,
1228 max_tx->dump_msdu_cnt);
1229 pos += scnprintf(buf + pos, bufsz - pos,
1230 fmt_table, "abort_nxt_frame_mismatch:",
1231 le32_to_cpu(tx->burst_abort_next_frame_mismatch_cnt),
1232 accum_tx->burst_abort_next_frame_mismatch_cnt,
1233 delta_tx->burst_abort_next_frame_mismatch_cnt,
1234 max_tx->burst_abort_next_frame_mismatch_cnt);
1235 pos += scnprintf(buf + pos, bufsz - pos,
1236 fmt_table, "abort_missing_nxt_frame:",
1237 le32_to_cpu(tx->burst_abort_missing_next_frame_cnt),
1238 accum_tx->burst_abort_missing_next_frame_cnt,
1239 delta_tx->burst_abort_missing_next_frame_cnt,
1240 max_tx->burst_abort_missing_next_frame_cnt);
1241 pos += scnprintf(buf + pos, bufsz - pos,
1242 fmt_table, "cts_timeout_collision:",
1243 le32_to_cpu(tx->cts_timeout_collision),
1244 accum_tx->cts_timeout_collision,
1245 delta_tx->cts_timeout_collision,
1246 max_tx->cts_timeout_collision);
1247 pos += scnprintf(buf + pos, bufsz - pos,
1248 fmt_table, "ack_ba_timeout_collision:",
1249 le32_to_cpu(tx->ack_or_ba_timeout_collision),
1250 accum_tx->ack_or_ba_timeout_collision,
1251 delta_tx->ack_or_ba_timeout_collision,
1252 max_tx->ack_or_ba_timeout_collision);
1253 pos += scnprintf(buf + pos, bufsz - pos,
1254 fmt_table, "agg ba_timeout:",
1255 le32_to_cpu(tx->agg.ba_timeout),
1256 accum_tx->agg.ba_timeout,
1257 delta_tx->agg.ba_timeout,
1258 max_tx->agg.ba_timeout);
1259 pos += scnprintf(buf + pos, bufsz - pos,
1260 fmt_table, "agg ba_resched_frames:",
1261 le32_to_cpu(tx->agg.ba_reschedule_frames),
1262 accum_tx->agg.ba_reschedule_frames,
1263 delta_tx->agg.ba_reschedule_frames,
1264 max_tx->agg.ba_reschedule_frames);
1265 pos += scnprintf(buf + pos, bufsz - pos,
1266 fmt_table, "agg scd_query_agg_frame:",
1267 le32_to_cpu(tx->agg.scd_query_agg_frame_cnt),
1268 accum_tx->agg.scd_query_agg_frame_cnt,
1269 delta_tx->agg.scd_query_agg_frame_cnt,
1270 max_tx->agg.scd_query_agg_frame_cnt);
1271 pos += scnprintf(buf + pos, bufsz - pos,
1272 fmt_table, "agg scd_query_no_agg:",
1273 le32_to_cpu(tx->agg.scd_query_no_agg),
1274 accum_tx->agg.scd_query_no_agg,
1275 delta_tx->agg.scd_query_no_agg,
1276 max_tx->agg.scd_query_no_agg);
1277 pos += scnprintf(buf + pos, bufsz - pos,
1278 fmt_table, "agg scd_query_agg:",
1279 le32_to_cpu(tx->agg.scd_query_agg),
1280 accum_tx->agg.scd_query_agg,
1281 delta_tx->agg.scd_query_agg,
1282 max_tx->agg.scd_query_agg);
1283 pos += scnprintf(buf + pos, bufsz - pos,
1284 fmt_table, "agg scd_query_mismatch:",
1285 le32_to_cpu(tx->agg.scd_query_mismatch),
1286 accum_tx->agg.scd_query_mismatch,
1287 delta_tx->agg.scd_query_mismatch,
1288 max_tx->agg.scd_query_mismatch);
1289 pos += scnprintf(buf + pos, bufsz - pos,
1290 fmt_table, "agg frame_not_ready:",
1291 le32_to_cpu(tx->agg.frame_not_ready),
1292 accum_tx->agg.frame_not_ready,
1293 delta_tx->agg.frame_not_ready,
1294 max_tx->agg.frame_not_ready);
1295 pos += scnprintf(buf + pos, bufsz - pos,
1296 fmt_table, "agg underrun:",
1297 le32_to_cpu(tx->agg.underrun),
1298 accum_tx->agg.underrun,
1299 delta_tx->agg.underrun, max_tx->agg.underrun);
1300 pos += scnprintf(buf + pos, bufsz - pos,
1301 fmt_table, "agg bt_prio_kill:",
1302 le32_to_cpu(tx->agg.bt_prio_kill),
1303 accum_tx->agg.bt_prio_kill,
1304 delta_tx->agg.bt_prio_kill,
1305 max_tx->agg.bt_prio_kill);
1306 pos += scnprintf(buf + pos, bufsz - pos,
1307 fmt_table, "agg rx_ba_rsp_cnt:",
1308 le32_to_cpu(tx->agg.rx_ba_rsp_cnt),
1309 accum_tx->agg.rx_ba_rsp_cnt,
1310 delta_tx->agg.rx_ba_rsp_cnt,
1311 max_tx->agg.rx_ba_rsp_cnt);
1313 if (tx->tx_power.ant_a || tx->tx_power.ant_b || tx->tx_power.ant_c) {
1314 pos += scnprintf(buf + pos, bufsz - pos,
1315 "tx power: (1/2 dB step)\n");
1316 if ((priv->nvm_data->valid_tx_ant & ANT_A) &&
1318 pos += scnprintf(buf + pos, bufsz - pos,
1319 fmt_hex, "antenna A:",
1320 tx->tx_power.ant_a);
1321 if ((priv->nvm_data->valid_tx_ant & ANT_B) &&
1323 pos += scnprintf(buf + pos, bufsz - pos,
1324 fmt_hex, "antenna B:",
1325 tx->tx_power.ant_b);
1326 if ((priv->nvm_data->valid_tx_ant & ANT_C) &&
1328 pos += scnprintf(buf + pos, bufsz - pos,
1329 fmt_hex, "antenna C:",
1330 tx->tx_power.ant_c);
1333 spin_unlock_bh(&priv->statistics.lock);
1335 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1340 static ssize_t iwl_dbgfs_ucode_general_stats_read(struct file *file,
1341 char __user *user_buf,
1342 size_t count, loff_t *ppos)
1344 struct iwl_priv *priv = file->private_data;
1347 int bufsz = sizeof(struct statistics_general) * 10 + 300;
1349 struct statistics_general_common *general, *accum_general;
1350 struct statistics_general_common *delta_general, *max_general;
1351 struct statistics_dbg *dbg, *accum_dbg, *delta_dbg, *max_dbg;
1352 struct statistics_div *div, *accum_div, *delta_div, *max_div;
1354 if (!iwl_is_alive(priv))
1357 buf = kzalloc(bufsz, GFP_KERNEL);
1361 /* the statistic information display here is based on
1362 * the last statistics notification from uCode
1363 * might not reflect the current uCode activity
1366 spin_lock_bh(&priv->statistics.lock);
1368 general = &priv->statistics.common;
1369 dbg = &priv->statistics.common.dbg;
1370 div = &priv->statistics.common.div;
1371 accum_general = &priv->accum_stats.common;
1372 accum_dbg = &priv->accum_stats.common.dbg;
1373 accum_div = &priv->accum_stats.common.div;
1374 delta_general = &priv->delta_stats.common;
1375 max_general = &priv->max_delta_stats.common;
1376 delta_dbg = &priv->delta_stats.common.dbg;
1377 max_dbg = &priv->max_delta_stats.common.dbg;
1378 delta_div = &priv->delta_stats.common.div;
1379 max_div = &priv->max_delta_stats.common.div;
1381 pos += iwl_statistics_flag(priv, buf, bufsz);
1382 pos += scnprintf(buf + pos, bufsz - pos,
1383 fmt_header, "Statistics_General:");
1384 pos += scnprintf(buf + pos, bufsz - pos,
1385 fmt_value, "temperature:",
1386 le32_to_cpu(general->temperature));
1387 pos += scnprintf(buf + pos, bufsz - pos,
1388 fmt_value, "temperature_m:",
1389 le32_to_cpu(general->temperature_m));
1390 pos += scnprintf(buf + pos, bufsz - pos,
1391 fmt_value, "ttl_timestamp:",
1392 le32_to_cpu(general->ttl_timestamp));
1393 pos += scnprintf(buf + pos, bufsz - pos,
1394 fmt_table, "burst_check:",
1395 le32_to_cpu(dbg->burst_check),
1396 accum_dbg->burst_check,
1397 delta_dbg->burst_check, max_dbg->burst_check);
1398 pos += scnprintf(buf + pos, bufsz - pos,
1399 fmt_table, "burst_count:",
1400 le32_to_cpu(dbg->burst_count),
1401 accum_dbg->burst_count,
1402 delta_dbg->burst_count, max_dbg->burst_count);
1403 pos += scnprintf(buf + pos, bufsz - pos,
1404 fmt_table, "wait_for_silence_timeout_count:",
1405 le32_to_cpu(dbg->wait_for_silence_timeout_cnt),
1406 accum_dbg->wait_for_silence_timeout_cnt,
1407 delta_dbg->wait_for_silence_timeout_cnt,
1408 max_dbg->wait_for_silence_timeout_cnt);
1409 pos += scnprintf(buf + pos, bufsz - pos,
1410 fmt_table, "sleep_time:",
1411 le32_to_cpu(general->sleep_time),
1412 accum_general->sleep_time,
1413 delta_general->sleep_time, max_general->sleep_time);
1414 pos += scnprintf(buf + pos, bufsz - pos,
1415 fmt_table, "slots_out:",
1416 le32_to_cpu(general->slots_out),
1417 accum_general->slots_out,
1418 delta_general->slots_out, max_general->slots_out);
1419 pos += scnprintf(buf + pos, bufsz - pos,
1420 fmt_table, "slots_idle:",
1421 le32_to_cpu(general->slots_idle),
1422 accum_general->slots_idle,
1423 delta_general->slots_idle, max_general->slots_idle);
1424 pos += scnprintf(buf + pos, bufsz - pos,
1425 fmt_table, "tx_on_a:",
1426 le32_to_cpu(div->tx_on_a), accum_div->tx_on_a,
1427 delta_div->tx_on_a, max_div->tx_on_a);
1428 pos += scnprintf(buf + pos, bufsz - pos,
1429 fmt_table, "tx_on_b:",
1430 le32_to_cpu(div->tx_on_b), accum_div->tx_on_b,
1431 delta_div->tx_on_b, max_div->tx_on_b);
1432 pos += scnprintf(buf + pos, bufsz - pos,
1433 fmt_table, "exec_time:",
1434 le32_to_cpu(div->exec_time), accum_div->exec_time,
1435 delta_div->exec_time, max_div->exec_time);
1436 pos += scnprintf(buf + pos, bufsz - pos,
1437 fmt_table, "probe_time:",
1438 le32_to_cpu(div->probe_time), accum_div->probe_time,
1439 delta_div->probe_time, max_div->probe_time);
1440 pos += scnprintf(buf + pos, bufsz - pos,
1441 fmt_table, "rx_enable_counter:",
1442 le32_to_cpu(general->rx_enable_counter),
1443 accum_general->rx_enable_counter,
1444 delta_general->rx_enable_counter,
1445 max_general->rx_enable_counter);
1446 pos += scnprintf(buf + pos, bufsz - pos,
1447 fmt_table, "num_of_sos_states:",
1448 le32_to_cpu(general->num_of_sos_states),
1449 accum_general->num_of_sos_states,
1450 delta_general->num_of_sos_states,
1451 max_general->num_of_sos_states);
1453 spin_unlock_bh(&priv->statistics.lock);
1455 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1460 static ssize_t iwl_dbgfs_ucode_bt_stats_read(struct file *file,
1461 char __user *user_buf,
1462 size_t count, loff_t *ppos)
1464 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
1467 int bufsz = (sizeof(struct statistics_bt_activity) * 24) + 200;
1469 struct statistics_bt_activity *bt, *accum_bt;
1471 if (!iwl_is_alive(priv))
1474 if (!priv->bt_enable_flag)
1477 /* make request to uCode to retrieve statistics information */
1478 mutex_lock(&priv->mutex);
1479 ret = iwl_send_statistics_request(priv, 0, false);
1480 mutex_unlock(&priv->mutex);
1484 buf = kzalloc(bufsz, GFP_KERNEL);
1489 * the statistic information display here is based on
1490 * the last statistics notification from uCode
1491 * might not reflect the current uCode activity
1494 spin_lock_bh(&priv->statistics.lock);
1496 bt = &priv->statistics.bt_activity;
1497 accum_bt = &priv->accum_stats.bt_activity;
1499 pos += iwl_statistics_flag(priv, buf, bufsz);
1500 pos += scnprintf(buf + pos, bufsz - pos, "Statistics_BT:\n");
1501 pos += scnprintf(buf + pos, bufsz - pos,
1502 "\t\t\tcurrent\t\t\taccumulative\n");
1503 pos += scnprintf(buf + pos, bufsz - pos,
1504 "hi_priority_tx_req_cnt:\t\t%u\t\t\t%u\n",
1505 le32_to_cpu(bt->hi_priority_tx_req_cnt),
1506 accum_bt->hi_priority_tx_req_cnt);
1507 pos += scnprintf(buf + pos, bufsz - pos,
1508 "hi_priority_tx_denied_cnt:\t%u\t\t\t%u\n",
1509 le32_to_cpu(bt->hi_priority_tx_denied_cnt),
1510 accum_bt->hi_priority_tx_denied_cnt);
1511 pos += scnprintf(buf + pos, bufsz - pos,
1512 "lo_priority_tx_req_cnt:\t\t%u\t\t\t%u\n",
1513 le32_to_cpu(bt->lo_priority_tx_req_cnt),
1514 accum_bt->lo_priority_tx_req_cnt);
1515 pos += scnprintf(buf + pos, bufsz - pos,
1516 "lo_priority_tx_denied_cnt:\t%u\t\t\t%u\n",
1517 le32_to_cpu(bt->lo_priority_tx_denied_cnt),
1518 accum_bt->lo_priority_tx_denied_cnt);
1519 pos += scnprintf(buf + pos, bufsz - pos,
1520 "hi_priority_rx_req_cnt:\t\t%u\t\t\t%u\n",
1521 le32_to_cpu(bt->hi_priority_rx_req_cnt),
1522 accum_bt->hi_priority_rx_req_cnt);
1523 pos += scnprintf(buf + pos, bufsz - pos,
1524 "hi_priority_rx_denied_cnt:\t%u\t\t\t%u\n",
1525 le32_to_cpu(bt->hi_priority_rx_denied_cnt),
1526 accum_bt->hi_priority_rx_denied_cnt);
1527 pos += scnprintf(buf + pos, bufsz - pos,
1528 "lo_priority_rx_req_cnt:\t\t%u\t\t\t%u\n",
1529 le32_to_cpu(bt->lo_priority_rx_req_cnt),
1530 accum_bt->lo_priority_rx_req_cnt);
1531 pos += scnprintf(buf + pos, bufsz - pos,
1532 "lo_priority_rx_denied_cnt:\t%u\t\t\t%u\n",
1533 le32_to_cpu(bt->lo_priority_rx_denied_cnt),
1534 accum_bt->lo_priority_rx_denied_cnt);
1536 pos += scnprintf(buf + pos, bufsz - pos,
1537 "(rx)num_bt_kills:\t\t%u\t\t\t%u\n",
1538 le32_to_cpu(priv->statistics.num_bt_kills),
1539 priv->statistics.accum_num_bt_kills);
1541 spin_unlock_bh(&priv->statistics.lock);
1543 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1548 static ssize_t iwl_dbgfs_reply_tx_error_read(struct file *file,
1549 char __user *user_buf,
1550 size_t count, loff_t *ppos)
1552 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
1555 int bufsz = (sizeof(struct reply_tx_error_statistics) * 24) +
1556 (sizeof(struct reply_agg_tx_error_statistics) * 24) + 200;
1559 if (!iwl_is_alive(priv))
1562 buf = kzalloc(bufsz, GFP_KERNEL);
1566 pos += scnprintf(buf + pos, bufsz - pos, "Statistics_TX_Error:\n");
1567 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t\t%u\n",
1568 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_DELAY),
1569 priv->reply_tx_stats.pp_delay);
1570 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1571 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_FEW_BYTES),
1572 priv->reply_tx_stats.pp_few_bytes);
1573 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1574 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_BT_PRIO),
1575 priv->reply_tx_stats.pp_bt_prio);
1576 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1577 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_QUIET_PERIOD),
1578 priv->reply_tx_stats.pp_quiet_period);
1579 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1580 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_CALC_TTAK),
1581 priv->reply_tx_stats.pp_calc_ttak);
1582 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1583 iwl_get_tx_fail_reason(
1584 TX_STATUS_FAIL_INTERNAL_CROSSED_RETRY),
1585 priv->reply_tx_stats.int_crossed_retry);
1586 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1587 iwl_get_tx_fail_reason(TX_STATUS_FAIL_SHORT_LIMIT),
1588 priv->reply_tx_stats.short_limit);
1589 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1590 iwl_get_tx_fail_reason(TX_STATUS_FAIL_LONG_LIMIT),
1591 priv->reply_tx_stats.long_limit);
1592 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1593 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FIFO_UNDERRUN),
1594 priv->reply_tx_stats.fifo_underrun);
1595 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1596 iwl_get_tx_fail_reason(TX_STATUS_FAIL_DRAIN_FLOW),
1597 priv->reply_tx_stats.drain_flow);
1598 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1599 iwl_get_tx_fail_reason(TX_STATUS_FAIL_RFKILL_FLUSH),
1600 priv->reply_tx_stats.rfkill_flush);
1601 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1602 iwl_get_tx_fail_reason(TX_STATUS_FAIL_LIFE_EXPIRE),
1603 priv->reply_tx_stats.life_expire);
1604 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1605 iwl_get_tx_fail_reason(TX_STATUS_FAIL_DEST_PS),
1606 priv->reply_tx_stats.dest_ps);
1607 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1608 iwl_get_tx_fail_reason(TX_STATUS_FAIL_HOST_ABORTED),
1609 priv->reply_tx_stats.host_abort);
1610 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1611 iwl_get_tx_fail_reason(TX_STATUS_FAIL_BT_RETRY),
1612 priv->reply_tx_stats.pp_delay);
1613 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1614 iwl_get_tx_fail_reason(TX_STATUS_FAIL_STA_INVALID),
1615 priv->reply_tx_stats.sta_invalid);
1616 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1617 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FRAG_DROPPED),
1618 priv->reply_tx_stats.frag_drop);
1619 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1620 iwl_get_tx_fail_reason(TX_STATUS_FAIL_TID_DISABLE),
1621 priv->reply_tx_stats.tid_disable);
1622 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1623 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FIFO_FLUSHED),
1624 priv->reply_tx_stats.fifo_flush);
1625 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1626 iwl_get_tx_fail_reason(
1627 TX_STATUS_FAIL_INSUFFICIENT_CF_POLL),
1628 priv->reply_tx_stats.insuff_cf_poll);
1629 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1630 iwl_get_tx_fail_reason(TX_STATUS_FAIL_PASSIVE_NO_RX),
1631 priv->reply_tx_stats.fail_hw_drop);
1632 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1633 iwl_get_tx_fail_reason(
1634 TX_STATUS_FAIL_NO_BEACON_ON_RADAR),
1635 priv->reply_tx_stats.sta_color_mismatch);
1636 pos += scnprintf(buf + pos, bufsz - pos, "UNKNOWN:\t\t\t%u\n",
1637 priv->reply_tx_stats.unknown);
1639 pos += scnprintf(buf + pos, bufsz - pos,
1640 "\nStatistics_Agg_TX_Error:\n");
1642 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1643 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_UNDERRUN_MSK),
1644 priv->reply_agg_tx_stats.underrun);
1645 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1646 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_BT_PRIO_MSK),
1647 priv->reply_agg_tx_stats.bt_prio);
1648 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1649 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_FEW_BYTES_MSK),
1650 priv->reply_agg_tx_stats.few_bytes);
1651 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1652 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_ABORT_MSK),
1653 priv->reply_agg_tx_stats.abort);
1654 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1655 iwl_get_agg_tx_fail_reason(
1656 AGG_TX_STATE_LAST_SENT_TTL_MSK),
1657 priv->reply_agg_tx_stats.last_sent_ttl);
1658 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1659 iwl_get_agg_tx_fail_reason(
1660 AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK),
1661 priv->reply_agg_tx_stats.last_sent_try);
1662 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1663 iwl_get_agg_tx_fail_reason(
1664 AGG_TX_STATE_LAST_SENT_BT_KILL_MSK),
1665 priv->reply_agg_tx_stats.last_sent_bt_kill);
1666 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1667 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_SCD_QUERY_MSK),
1668 priv->reply_agg_tx_stats.scd_query);
1669 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1670 iwl_get_agg_tx_fail_reason(
1671 AGG_TX_STATE_TEST_BAD_CRC32_MSK),
1672 priv->reply_agg_tx_stats.bad_crc32);
1673 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1674 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_RESPONSE_MSK),
1675 priv->reply_agg_tx_stats.response);
1676 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1677 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_DUMP_TX_MSK),
1678 priv->reply_agg_tx_stats.dump_tx);
1679 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1680 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_DELAY_TX_MSK),
1681 priv->reply_agg_tx_stats.delay_tx);
1682 pos += scnprintf(buf + pos, bufsz - pos, "UNKNOWN:\t\t\t%u\n",
1683 priv->reply_agg_tx_stats.unknown);
1685 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1690 static ssize_t iwl_dbgfs_sensitivity_read(struct file *file,
1691 char __user *user_buf,
1692 size_t count, loff_t *ppos) {
1694 struct iwl_priv *priv = file->private_data;
1698 int bufsz = sizeof(struct iwl_sensitivity_data) * 4 + 100;
1700 struct iwl_sensitivity_data *data;
1702 data = &priv->sensitivity_data;
1703 buf = kzalloc(bufsz, GFP_KERNEL);
1707 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm:\t\t\t %u\n",
1708 data->auto_corr_ofdm);
1709 pos += scnprintf(buf + pos, bufsz - pos,
1710 "auto_corr_ofdm_mrc:\t\t %u\n",
1711 data->auto_corr_ofdm_mrc);
1712 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_x1:\t\t %u\n",
1713 data->auto_corr_ofdm_x1);
1714 pos += scnprintf(buf + pos, bufsz - pos,
1715 "auto_corr_ofdm_mrc_x1:\t\t %u\n",
1716 data->auto_corr_ofdm_mrc_x1);
1717 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_cck:\t\t\t %u\n",
1718 data->auto_corr_cck);
1719 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_cck_mrc:\t\t %u\n",
1720 data->auto_corr_cck_mrc);
1721 pos += scnprintf(buf + pos, bufsz - pos,
1722 "last_bad_plcp_cnt_ofdm:\t\t %u\n",
1723 data->last_bad_plcp_cnt_ofdm);
1724 pos += scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_ofdm:\t\t %u\n",
1725 data->last_fa_cnt_ofdm);
1726 pos += scnprintf(buf + pos, bufsz - pos,
1727 "last_bad_plcp_cnt_cck:\t\t %u\n",
1728 data->last_bad_plcp_cnt_cck);
1729 pos += scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_cck:\t\t %u\n",
1730 data->last_fa_cnt_cck);
1731 pos += scnprintf(buf + pos, bufsz - pos, "nrg_curr_state:\t\t\t %u\n",
1732 data->nrg_curr_state);
1733 pos += scnprintf(buf + pos, bufsz - pos, "nrg_prev_state:\t\t\t %u\n",
1734 data->nrg_prev_state);
1735 pos += scnprintf(buf + pos, bufsz - pos, "nrg_value:\t\t\t");
1736 for (cnt = 0; cnt < 10; cnt++) {
1737 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1738 data->nrg_value[cnt]);
1740 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1741 pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_rssi:\t\t");
1742 for (cnt = 0; cnt < NRG_NUM_PREV_STAT_L; cnt++) {
1743 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1744 data->nrg_silence_rssi[cnt]);
1746 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1747 pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_ref:\t\t %u\n",
1748 data->nrg_silence_ref);
1749 pos += scnprintf(buf + pos, bufsz - pos, "nrg_energy_idx:\t\t\t %u\n",
1750 data->nrg_energy_idx);
1751 pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_idx:\t\t %u\n",
1752 data->nrg_silence_idx);
1753 pos += scnprintf(buf + pos, bufsz - pos, "nrg_th_cck:\t\t\t %u\n",
1755 pos += scnprintf(buf + pos, bufsz - pos,
1756 "nrg_auto_corr_silence_diff:\t %u\n",
1757 data->nrg_auto_corr_silence_diff);
1758 pos += scnprintf(buf + pos, bufsz - pos, "num_in_cck_no_fa:\t\t %u\n",
1759 data->num_in_cck_no_fa);
1760 pos += scnprintf(buf + pos, bufsz - pos, "nrg_th_ofdm:\t\t\t %u\n",
1763 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1769 static ssize_t iwl_dbgfs_chain_noise_read(struct file *file,
1770 char __user *user_buf,
1771 size_t count, loff_t *ppos) {
1773 struct iwl_priv *priv = file->private_data;
1777 int bufsz = sizeof(struct iwl_chain_noise_data) * 4 + 100;
1779 struct iwl_chain_noise_data *data;
1781 data = &priv->chain_noise_data;
1782 buf = kzalloc(bufsz, GFP_KERNEL);
1786 pos += scnprintf(buf + pos, bufsz - pos, "active_chains:\t\t\t %u\n",
1787 data->active_chains);
1788 pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_a:\t\t\t %u\n",
1789 data->chain_noise_a);
1790 pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_b:\t\t\t %u\n",
1791 data->chain_noise_b);
1792 pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_c:\t\t\t %u\n",
1793 data->chain_noise_c);
1794 pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_a:\t\t\t %u\n",
1795 data->chain_signal_a);
1796 pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_b:\t\t\t %u\n",
1797 data->chain_signal_b);
1798 pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_c:\t\t\t %u\n",
1799 data->chain_signal_c);
1800 pos += scnprintf(buf + pos, bufsz - pos, "beacon_count:\t\t\t %u\n",
1801 data->beacon_count);
1803 pos += scnprintf(buf + pos, bufsz - pos, "disconn_array:\t\t\t");
1804 for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
1805 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1806 data->disconn_array[cnt]);
1808 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1809 pos += scnprintf(buf + pos, bufsz - pos, "delta_gain_code:\t\t");
1810 for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
1811 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1812 data->delta_gain_code[cnt]);
1814 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1815 pos += scnprintf(buf + pos, bufsz - pos, "radio_write:\t\t\t %u\n",
1817 pos += scnprintf(buf + pos, bufsz - pos, "state:\t\t\t\t %u\n",
1820 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1825 static ssize_t iwl_dbgfs_power_save_status_read(struct file *file,
1826 char __user *user_buf,
1827 size_t count, loff_t *ppos)
1829 struct iwl_priv *priv = file->private_data;
1832 const size_t bufsz = sizeof(buf);
1835 pwrsave_status = iwl_read32(priv->trans, CSR_GP_CNTRL) &
1836 CSR_GP_REG_POWER_SAVE_STATUS_MSK;
1838 pos += scnprintf(buf + pos, bufsz - pos, "Power Save Status: ");
1839 pos += scnprintf(buf + pos, bufsz - pos, "%s\n",
1840 (pwrsave_status == CSR_GP_REG_NO_POWER_SAVE) ? "none" :
1841 (pwrsave_status == CSR_GP_REG_MAC_POWER_SAVE) ? "MAC" :
1842 (pwrsave_status == CSR_GP_REG_PHY_POWER_SAVE) ? "PHY" :
1845 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1848 static ssize_t iwl_dbgfs_clear_ucode_statistics_write(struct file *file,
1849 const char __user *user_buf,
1850 size_t count, loff_t *ppos)
1852 struct iwl_priv *priv = file->private_data;
1857 memset(buf, 0, sizeof(buf));
1858 buf_size = min(count, sizeof(buf) - 1);
1859 if (copy_from_user(buf, user_buf, buf_size))
1861 if (sscanf(buf, "%d", &clear) != 1)
1864 /* make request to uCode to retrieve statistics information */
1865 mutex_lock(&priv->mutex);
1866 iwl_send_statistics_request(priv, 0, true);
1867 mutex_unlock(&priv->mutex);
1872 static ssize_t iwl_dbgfs_ucode_tracing_read(struct file *file,
1873 char __user *user_buf,
1874 size_t count, loff_t *ppos) {
1876 struct iwl_priv *priv = file->private_data;
1879 const size_t bufsz = sizeof(buf);
1881 pos += scnprintf(buf + pos, bufsz - pos, "ucode trace timer is %s\n",
1882 priv->event_log.ucode_trace ? "On" : "Off");
1883 pos += scnprintf(buf + pos, bufsz - pos, "non_wraps_count:\t\t %u\n",
1884 priv->event_log.non_wraps_count);
1885 pos += scnprintf(buf + pos, bufsz - pos, "wraps_once_count:\t\t %u\n",
1886 priv->event_log.wraps_once_count);
1887 pos += scnprintf(buf + pos, bufsz - pos, "wraps_more_count:\t\t %u\n",
1888 priv->event_log.wraps_more_count);
1890 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1893 static ssize_t iwl_dbgfs_ucode_tracing_write(struct file *file,
1894 const char __user *user_buf,
1895 size_t count, loff_t *ppos)
1897 struct iwl_priv *priv = file->private_data;
1902 memset(buf, 0, sizeof(buf));
1903 buf_size = min(count, sizeof(buf) - 1);
1904 if (copy_from_user(buf, user_buf, buf_size))
1906 if (sscanf(buf, "%d", &trace) != 1)
1910 priv->event_log.ucode_trace = true;
1911 if (iwl_is_alive(priv)) {
1912 /* start collecting data now */
1913 mod_timer(&priv->ucode_trace, jiffies);
1916 priv->event_log.ucode_trace = false;
1917 del_timer_sync(&priv->ucode_trace);
1923 static ssize_t iwl_dbgfs_rxon_flags_read(struct file *file,
1924 char __user *user_buf,
1925 size_t count, loff_t *ppos) {
1927 struct iwl_priv *priv = file->private_data;
1931 len = sprintf(buf, "0x%04X\n",
1932 le32_to_cpu(priv->contexts[IWL_RXON_CTX_BSS].active.flags));
1933 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1936 static ssize_t iwl_dbgfs_rxon_filter_flags_read(struct file *file,
1937 char __user *user_buf,
1938 size_t count, loff_t *ppos) {
1940 struct iwl_priv *priv = file->private_data;
1944 len = sprintf(buf, "0x%04X\n",
1945 le32_to_cpu(priv->contexts[IWL_RXON_CTX_BSS].active.filter_flags));
1946 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1949 static ssize_t iwl_dbgfs_missed_beacon_read(struct file *file,
1950 char __user *user_buf,
1951 size_t count, loff_t *ppos) {
1953 struct iwl_priv *priv = file->private_data;
1956 const size_t bufsz = sizeof(buf);
1958 pos += scnprintf(buf + pos, bufsz - pos, "%d\n",
1959 priv->missed_beacon_threshold);
1961 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1964 static ssize_t iwl_dbgfs_missed_beacon_write(struct file *file,
1965 const char __user *user_buf,
1966 size_t count, loff_t *ppos)
1968 struct iwl_priv *priv = file->private_data;
1973 memset(buf, 0, sizeof(buf));
1974 buf_size = min(count, sizeof(buf) - 1);
1975 if (copy_from_user(buf, user_buf, buf_size))
1977 if (sscanf(buf, "%d", &missed) != 1)
1980 if (missed < IWL_MISSED_BEACON_THRESHOLD_MIN ||
1981 missed > IWL_MISSED_BEACON_THRESHOLD_MAX)
1982 priv->missed_beacon_threshold =
1983 IWL_MISSED_BEACON_THRESHOLD_DEF;
1985 priv->missed_beacon_threshold = missed;
1990 static ssize_t iwl_dbgfs_plcp_delta_read(struct file *file,
1991 char __user *user_buf,
1992 size_t count, loff_t *ppos) {
1994 struct iwl_priv *priv = file->private_data;
1997 const size_t bufsz = sizeof(buf);
1999 pos += scnprintf(buf + pos, bufsz - pos, "%u\n",
2000 priv->plcp_delta_threshold);
2002 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2005 static ssize_t iwl_dbgfs_plcp_delta_write(struct file *file,
2006 const char __user *user_buf,
2007 size_t count, loff_t *ppos) {
2009 struct iwl_priv *priv = file->private_data;
2014 memset(buf, 0, sizeof(buf));
2015 buf_size = min(count, sizeof(buf) - 1);
2016 if (copy_from_user(buf, user_buf, buf_size))
2018 if (sscanf(buf, "%d", &plcp) != 1)
2020 if ((plcp < IWL_MAX_PLCP_ERR_THRESHOLD_MIN) ||
2021 (plcp > IWL_MAX_PLCP_ERR_THRESHOLD_MAX))
2022 priv->plcp_delta_threshold =
2023 IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE;
2025 priv->plcp_delta_threshold = plcp;
2029 static ssize_t iwl_dbgfs_rf_reset_read(struct file *file,
2030 char __user *user_buf,
2031 size_t count, loff_t *ppos)
2033 struct iwl_priv *priv = file->private_data;
2036 const size_t bufsz = sizeof(buf);
2037 struct iwl_rf_reset *rf_reset = &priv->rf_reset;
2039 pos += scnprintf(buf + pos, bufsz - pos,
2040 "RF reset statistics\n");
2041 pos += scnprintf(buf + pos, bufsz - pos,
2042 "\tnumber of reset request: %d\n",
2043 rf_reset->reset_request_count);
2044 pos += scnprintf(buf + pos, bufsz - pos,
2045 "\tnumber of reset request success: %d\n",
2046 rf_reset->reset_success_count);
2047 pos += scnprintf(buf + pos, bufsz - pos,
2048 "\tnumber of reset request reject: %d\n",
2049 rf_reset->reset_reject_count);
2051 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2054 static ssize_t iwl_dbgfs_rf_reset_write(struct file *file,
2055 const char __user *user_buf,
2056 size_t count, loff_t *ppos) {
2058 struct iwl_priv *priv = file->private_data;
2061 ret = iwl_force_rf_reset(priv, true);
2062 return ret ? ret : count;
2065 static ssize_t iwl_dbgfs_txfifo_flush_write(struct file *file,
2066 const char __user *user_buf,
2067 size_t count, loff_t *ppos) {
2069 struct iwl_priv *priv = file->private_data;
2074 memset(buf, 0, sizeof(buf));
2075 buf_size = min(count, sizeof(buf) - 1);
2076 if (copy_from_user(buf, user_buf, buf_size))
2078 if (sscanf(buf, "%d", &flush) != 1)
2081 if (iwl_is_rfkill(priv))
2084 iwlagn_dev_txfifo_flush(priv);
2089 static ssize_t iwl_dbgfs_bt_traffic_read(struct file *file,
2090 char __user *user_buf,
2091 size_t count, loff_t *ppos) {
2093 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
2096 const size_t bufsz = sizeof(buf);
2098 if (!priv->bt_enable_flag) {
2099 pos += scnprintf(buf + pos, bufsz - pos, "BT coex disabled\n");
2100 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2102 pos += scnprintf(buf + pos, bufsz - pos, "BT enable flag: 0x%x\n",
2103 priv->bt_enable_flag);
2104 pos += scnprintf(buf + pos, bufsz - pos, "BT in %s mode\n",
2105 priv->bt_full_concurrent ? "full concurrency" : "3-wire");
2106 pos += scnprintf(buf + pos, bufsz - pos, "BT status: %s, "
2107 "last traffic notif: %d\n",
2108 priv->bt_status ? "On" : "Off", priv->last_bt_traffic_load);
2109 pos += scnprintf(buf + pos, bufsz - pos, "ch_announcement: %d, "
2110 "kill_ack_mask: %x, kill_cts_mask: %x\n",
2111 priv->bt_ch_announce, priv->kill_ack_mask,
2112 priv->kill_cts_mask);
2114 pos += scnprintf(buf + pos, bufsz - pos, "bluetooth traffic load: ");
2115 switch (priv->bt_traffic_load) {
2116 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
2117 pos += scnprintf(buf + pos, bufsz - pos, "Continuous\n");
2119 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH:
2120 pos += scnprintf(buf + pos, bufsz - pos, "High\n");
2122 case IWL_BT_COEX_TRAFFIC_LOAD_LOW:
2123 pos += scnprintf(buf + pos, bufsz - pos, "Low\n");
2125 case IWL_BT_COEX_TRAFFIC_LOAD_NONE:
2127 pos += scnprintf(buf + pos, bufsz - pos, "None\n");
2131 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2134 static ssize_t iwl_dbgfs_protection_mode_read(struct file *file,
2135 char __user *user_buf,
2136 size_t count, loff_t *ppos)
2138 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
2142 const size_t bufsz = sizeof(buf);
2144 if (priv->cfg->ht_params)
2145 pos += scnprintf(buf + pos, bufsz - pos,
2146 "use %s for aggregation\n",
2147 (priv->hw_params.use_rts_for_aggregation) ?
2148 "rts/cts" : "cts-to-self");
2150 pos += scnprintf(buf + pos, bufsz - pos, "N/A");
2152 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2155 static ssize_t iwl_dbgfs_protection_mode_write(struct file *file,
2156 const char __user *user_buf,
2157 size_t count, loff_t *ppos) {
2159 struct iwl_priv *priv = file->private_data;
2164 if (!priv->cfg->ht_params)
2167 memset(buf, 0, sizeof(buf));
2168 buf_size = min(count, sizeof(buf) - 1);
2169 if (copy_from_user(buf, user_buf, buf_size))
2171 if (sscanf(buf, "%d", &rts) != 1)
2174 priv->hw_params.use_rts_for_aggregation = true;
2176 priv->hw_params.use_rts_for_aggregation = false;
2180 static int iwl_cmd_echo_test(struct iwl_priv *priv)
2183 struct iwl_host_cmd cmd = {
2188 ret = iwl_dvm_send_cmd(priv, &cmd);
2190 IWL_ERR(priv, "echo testing fail: 0X%x\n", ret);
2192 IWL_DEBUG_INFO(priv, "echo testing pass\n");
2196 static ssize_t iwl_dbgfs_echo_test_write(struct file *file,
2197 const char __user *user_buf,
2198 size_t count, loff_t *ppos)
2200 struct iwl_priv *priv = file->private_data;
2204 memset(buf, 0, sizeof(buf));
2205 buf_size = min(count, sizeof(buf) - 1);
2206 if (copy_from_user(buf, user_buf, buf_size))
2209 iwl_cmd_echo_test(priv);
2213 #ifdef CONFIG_IWLWIFI_DEBUG
2214 static ssize_t iwl_dbgfs_log_event_read(struct file *file,
2215 char __user *user_buf,
2216 size_t count, loff_t *ppos)
2218 struct iwl_priv *priv = file->private_data;
2222 ret = iwl_dump_nic_event_log(priv, true, &buf);
2224 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
2229 static ssize_t iwl_dbgfs_log_event_write(struct file *file,
2230 const char __user *user_buf,
2231 size_t count, loff_t *ppos)
2233 struct iwl_priv *priv = file->private_data;
2238 /* check that the interface is up */
2239 if (!iwl_is_ready(priv))
2242 memset(buf, 0, sizeof(buf));
2243 buf_size = min(count, sizeof(buf) - 1);
2244 if (copy_from_user(buf, user_buf, buf_size))
2246 if (sscanf(buf, "%d", &event_log_flag) != 1)
2248 if (event_log_flag == 1)
2249 iwl_dump_nic_event_log(priv, true, NULL);
2255 static ssize_t iwl_dbgfs_calib_disabled_read(struct file *file,
2256 char __user *user_buf,
2257 size_t count, loff_t *ppos)
2259 struct iwl_priv *priv = file->private_data;
2262 const size_t bufsz = sizeof(buf);
2264 pos += scnprintf(buf + pos, bufsz - pos,
2265 "Sensitivity calibrations %s\n",
2266 (priv->calib_disabled &
2267 IWL_SENSITIVITY_CALIB_DISABLED) ?
2268 "DISABLED" : "ENABLED");
2269 pos += scnprintf(buf + pos, bufsz - pos,
2270 "Chain noise calibrations %s\n",
2271 (priv->calib_disabled &
2272 IWL_CHAIN_NOISE_CALIB_DISABLED) ?
2273 "DISABLED" : "ENABLED");
2274 pos += scnprintf(buf + pos, bufsz - pos,
2275 "Tx power calibrations %s\n",
2276 (priv->calib_disabled &
2277 IWL_TX_POWER_CALIB_DISABLED) ?
2278 "DISABLED" : "ENABLED");
2280 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2283 static ssize_t iwl_dbgfs_calib_disabled_write(struct file *file,
2284 const char __user *user_buf,
2285 size_t count, loff_t *ppos)
2287 struct iwl_priv *priv = file->private_data;
2292 memset(buf, 0, sizeof(buf));
2293 buf_size = min(count, sizeof(buf) - 1);
2294 if (copy_from_user(buf, user_buf, buf_size))
2296 if (sscanf(buf, "%x", &calib_disabled) != 1)
2299 priv->calib_disabled = calib_disabled;
2304 static ssize_t iwl_dbgfs_fw_restart_write(struct file *file,
2305 const char __user *user_buf,
2306 size_t count, loff_t *ppos)
2308 struct iwl_priv *priv = file->private_data;
2309 bool fw_restart = iwlwifi_mod_params.fw_restart;
2310 int __maybe_unused ret;
2312 iwlwifi_mod_params.fw_restart = true;
2314 mutex_lock(&priv->mutex);
2316 /* take the return value to make compiler happy - it will fail anyway */
2317 ret = iwl_dvm_send_cmd_pdu(priv, REPLY_ERROR, 0, 0, NULL);
2319 mutex_unlock(&priv->mutex);
2321 iwlwifi_mod_params.fw_restart = fw_restart;
2326 DEBUGFS_READ_FILE_OPS(ucode_rx_stats);
2327 DEBUGFS_READ_FILE_OPS(ucode_tx_stats);
2328 DEBUGFS_READ_FILE_OPS(ucode_general_stats);
2329 DEBUGFS_READ_FILE_OPS(sensitivity);
2330 DEBUGFS_READ_FILE_OPS(chain_noise);
2331 DEBUGFS_READ_FILE_OPS(power_save_status);
2332 DEBUGFS_WRITE_FILE_OPS(clear_ucode_statistics);
2333 DEBUGFS_READ_WRITE_FILE_OPS(ucode_tracing);
2334 DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon);
2335 DEBUGFS_READ_WRITE_FILE_OPS(plcp_delta);
2336 DEBUGFS_READ_WRITE_FILE_OPS(rf_reset);
2337 DEBUGFS_READ_FILE_OPS(rxon_flags);
2338 DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
2339 DEBUGFS_WRITE_FILE_OPS(txfifo_flush);
2340 DEBUGFS_READ_FILE_OPS(ucode_bt_stats);
2341 DEBUGFS_READ_FILE_OPS(bt_traffic);
2342 DEBUGFS_READ_WRITE_FILE_OPS(protection_mode);
2343 DEBUGFS_READ_FILE_OPS(reply_tx_error);
2344 DEBUGFS_WRITE_FILE_OPS(echo_test);
2345 DEBUGFS_WRITE_FILE_OPS(fw_restart);
2346 #ifdef CONFIG_IWLWIFI_DEBUG
2347 DEBUGFS_READ_WRITE_FILE_OPS(log_event);
2349 DEBUGFS_READ_WRITE_FILE_OPS(calib_disabled);
2352 * Create the debugfs files and directories
2355 int iwl_dbgfs_register(struct iwl_priv *priv, struct dentry *dbgfs_dir)
2357 struct dentry *dir_data, *dir_rf, *dir_debug;
2359 priv->debugfs_dir = dbgfs_dir;
2361 dir_data = debugfs_create_dir("data", dbgfs_dir);
2364 dir_rf = debugfs_create_dir("rf", dbgfs_dir);
2367 dir_debug = debugfs_create_dir("debug", dbgfs_dir);
2371 DEBUGFS_ADD_FILE(nvm, dir_data, 0400);
2372 DEBUGFS_ADD_FILE(sram, dir_data, 0600);
2373 DEBUGFS_ADD_FILE(wowlan_sram, dir_data, 0400);
2374 DEBUGFS_ADD_FILE(stations, dir_data, 0400);
2375 DEBUGFS_ADD_FILE(channels, dir_data, 0400);
2376 DEBUGFS_ADD_FILE(status, dir_data, 0400);
2377 DEBUGFS_ADD_FILE(rx_handlers, dir_data, 0600);
2378 DEBUGFS_ADD_FILE(qos, dir_data, 0400);
2379 DEBUGFS_ADD_FILE(sleep_level_override, dir_data, 0600);
2380 DEBUGFS_ADD_FILE(current_sleep_command, dir_data, 0400);
2381 DEBUGFS_ADD_FILE(thermal_throttling, dir_data, 0400);
2382 DEBUGFS_ADD_FILE(disable_ht40, dir_data, 0600);
2383 DEBUGFS_ADD_FILE(temperature, dir_data, 0400);
2385 DEBUGFS_ADD_FILE(power_save_status, dir_debug, 0400);
2386 DEBUGFS_ADD_FILE(clear_ucode_statistics, dir_debug, 0200);
2387 DEBUGFS_ADD_FILE(missed_beacon, dir_debug, 0200);
2388 DEBUGFS_ADD_FILE(plcp_delta, dir_debug, 0600);
2389 DEBUGFS_ADD_FILE(rf_reset, dir_debug, 0600);
2390 DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, 0400);
2391 DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, 0400);
2392 DEBUGFS_ADD_FILE(ucode_general_stats, dir_debug, 0400);
2393 DEBUGFS_ADD_FILE(txfifo_flush, dir_debug, 0200);
2394 DEBUGFS_ADD_FILE(protection_mode, dir_debug, 0600);
2395 DEBUGFS_ADD_FILE(sensitivity, dir_debug, 0400);
2396 DEBUGFS_ADD_FILE(chain_noise, dir_debug, 0400);
2397 DEBUGFS_ADD_FILE(ucode_tracing, dir_debug, 0600);
2398 DEBUGFS_ADD_FILE(ucode_bt_stats, dir_debug, 0400);
2399 DEBUGFS_ADD_FILE(reply_tx_error, dir_debug, 0400);
2400 DEBUGFS_ADD_FILE(rxon_flags, dir_debug, 0200);
2401 DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, 0200);
2402 DEBUGFS_ADD_FILE(echo_test, dir_debug, 0200);
2403 DEBUGFS_ADD_FILE(fw_restart, dir_debug, 0200);
2404 #ifdef CONFIG_IWLWIFI_DEBUG
2405 DEBUGFS_ADD_FILE(log_event, dir_debug, 0600);
2408 if (iwl_advanced_bt_coexist(priv))
2409 DEBUGFS_ADD_FILE(bt_traffic, dir_debug, 0400);
2411 /* Calibrations disabled/enabled status*/
2412 DEBUGFS_ADD_FILE(calib_disabled, dir_rf, 0600);
2415 * Create a symlink with mac80211. This is not very robust, as it does
2416 * not remove the symlink created. The implicit assumption is that
2417 * when the opmode exits, mac80211 will also exit, and will remove
2418 * this symlink as part of its cleanup.
2420 if (priv->mac80211_registered) {
2422 struct dentry *mac80211_dir, *dev_dir;
2424 dev_dir = dbgfs_dir->d_parent;
2425 mac80211_dir = priv->hw->wiphy->debugfsdir;
2427 snprintf(buf, 100, "../../%pd2", dev_dir);
2429 if (!debugfs_create_symlink("iwlwifi", mac80211_dir, buf))
2436 IWL_ERR(priv, "failed to create the dvm debugfs entries\n");