projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'mmc-uh/next'
[deliverable/linux.git] / drivers / net / wireless / intel / iwlwifi / dvm / debugfs.c
CommitLineData
712b6cf5
TW		 1/******************************************************************************
2 *
3 * GPL LICENSE SUMMARY
4 *
51368bf7 5 * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
712b6cf5
TW		 6 *
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.
10 *
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.
15 *
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,
19 * USA
20 *
21 * The full GNU General Public License is included in this distribution
410dc5aa 22 * in the file called COPYING.
712b6cf5
TW		 23 *
24 * Contact Information:
cb2f8277 25 * Intel Linux Wireless <linuxwifi@intel.com>
712b6cf5
TW		 26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *****************************************************************************/
28
5a0e3ad6 29#include <linux/slab.h>
712b6cf5
TW		 30#include <linux/kernel.h>
31#include <linux/module.h>
32#include <linux/debugfs.h>
712b6cf5
TW		 33#include <linux/ieee80211.h>
34#include <net/mac80211.h>
39bdb17e 35
712b6cf5 36#include "iwl-debug.h"
39bdb17e 37#include "iwl-trans.h"
3395f6e9 38#include "iwl-io.h"
1023fdc4
JB		 39#include "dev.h"
40#include "agn.h"
712b6cf5
TW		 41
42/* create and remove of files */
4c84a8f1
JB		 43#define DEBUGFS_ADD_FILE(name, parent, mode) do { \
44 if (!debugfs_create_file(#name, mode, parent, priv, \
45 &iwl_dbgfs_##name##_ops)) \
46 goto err; \
712b6cf5
TW		 47} while (0)
48
4c84a8f1
JB		 49#define DEBUGFS_ADD_BOOL(name, parent, ptr) do { \
50 struct dentry *__tmp; \
51 __tmp = debugfs_create_bool(#name, S_IWUSR | S_IRUSR, \
52 parent, ptr); \
53 if (IS_ERR(__tmp) || !__tmp) \
54 goto err; \
712b6cf5
TW		 55} while (0)
56
4c84a8f1
JB		 57#define DEBUGFS_ADD_X32(name, parent, ptr) do { \
58 struct dentry *__tmp; \
59 __tmp = debugfs_create_x32(#name, S_IWUSR | S_IRUSR, \
60 parent, ptr); \
61 if (IS_ERR(__tmp) || !__tmp) \
62 goto err; \
445c2dff
TW		 63} while (0)
64
ca934b67
JB		 65#define DEBUGFS_ADD_U32(name, parent, ptr, mode) do { \
66 struct dentry *__tmp; \
67 __tmp = debugfs_create_u32(#name, mode, \
68 parent, ptr); \
69 if (IS_ERR(__tmp) || !__tmp) \
70 goto err; \
71} while (0)
72
712b6cf5 73/* file operation */
712b6cf5 74#define DEBUGFS_READ_FILE_OPS(name) \
712b6cf5 75static const struct file_operations iwl_dbgfs_##name##_ops = { \
0ff1bd35 76 .read = iwl_dbgfs_##name##_read, \
234e3405 77 .open = simple_open, \
2b18ab36 78 .llseek = generic_file_llseek, \
712b6cf5
TW		 79};
80
189a2b59 81#define DEBUGFS_WRITE_FILE_OPS(name) \
189a2b59
EK		 82static const struct file_operations iwl_dbgfs_##name##_ops = { \
83 .write = iwl_dbgfs_##name##_write, \
234e3405 84 .open = simple_open, \
2b18ab36 85 .llseek = generic_file_llseek, \
189a2b59
EK		 86};
87
88
712b6cf5 89#define DEBUGFS_READ_WRITE_FILE_OPS(name) \
712b6cf5
TW		 90static const struct file_operations iwl_dbgfs_##name##_ops = { \
91 .write = iwl_dbgfs_##name##_write, \
92 .read = iwl_dbgfs_##name##_read, \
234e3405 93 .open = simple_open, \
2b18ab36 94 .llseek = generic_file_llseek, \
712b6cf5
TW		 95};
96
712b6cf5
TW		 97static ssize_t iwl_dbgfs_sram_read(struct file *file,
98 char __user *user_buf,
99 size_t count, loff_t *ppos)
100{
24834d2c 101 u32 val = 0;
2943f136 102 char *buf;
712b6cf5 103 ssize_t ret;
24834d2c
JS		 104 int i = 0;
105 bool device_format = false;
106 int offset = 0;
107 int len = 0;
712b6cf5 108 int pos = 0;
24834d2c 109 int sram;
28f63a4b 110 struct iwl_priv *priv = file->private_data;
6dfa8d01 111 const struct fw_img *img;
2943f136 112 size_t bufsz;
712b6cf5 113
4fc79db1
JB		 114 if (!iwl_is_ready_rf(priv))
115 return -EAGAIN;
116
5ade1e4d 117 /* default is to dump the entire data segment */
4c84a8f1
JB		 118 if (!priv->dbgfs_sram_offset && !priv->dbgfs_sram_len) {
119 priv->dbgfs_sram_offset = 0x800000;
f9e75447 120 if (!priv->ucode_loaded)
8f7ffbe2 121 return -EINVAL;
a42506eb 122 img = &priv->fw->img[priv->cur_ucode];
6dfa8d01 123 priv->dbgfs_sram_len = img->sec[IWL_UCODE_SECTION_DATA].len;
5ade1e4d 124 }
24834d2c
JS		 125 len = priv->dbgfs_sram_len;
126
127 if (len == -4) {
128 device_format = true;
129 len = 4;
130 }
131
132 bufsz = 50 + len * 4;
2943f136
WYG		 133 buf = kmalloc(bufsz, GFP_KERNEL);
134 if (!buf)
135 return -ENOMEM;
24834d2c 136
5ade1e4d 137 pos += scnprintf(buf + pos, bufsz - pos, "sram_len: 0x%x\n",
24834d2c 138 len);
5ade1e4d 139 pos += scnprintf(buf + pos, bufsz - pos, "sram_offset: 0x%x\n",
4c84a8f1 140 priv->dbgfs_sram_offset);
24834d2c
JS		 141
142 /* adjust sram address since reads are only on even u32 boundaries */
143 offset = priv->dbgfs_sram_offset & 0x3;
144 sram = priv->dbgfs_sram_offset & ~0x3;
145
146 /* read the first u32 from sram */
4fd442db 147 val = iwl_trans_read_mem32(priv->trans, sram);
24834d2c
JS		 148
149 for (; len; len--) {
150 /* put the address at the start of every line */
151 if (i == 0)
152 pos += scnprintf(buf + pos, bufsz - pos,
153 "%08X: ", sram + offset);
154
155 if (device_format)
156 pos += scnprintf(buf + pos, bufsz - pos,
157 "%02x", (val >> (8 * (3 - offset))) & 0xff);
158 else
159 pos += scnprintf(buf + pos, bufsz - pos,
160 "%02x ", (val >> (8 * offset)) & 0xff);
161
162 /* if all bytes processed, read the next u32 from sram */
163 if (++offset == 4) {
164 sram += 4;
165 offset = 0;
4fd442db 166 val = iwl_trans_read_mem32(priv->trans, sram);
712b6cf5 167 }
24834d2c
JS		 168
169 /* put in extra spaces and split lines for human readability */
170 if (++i == 16) {
171 i = 0;
2943f136 172 pos += scnprintf(buf + pos, bufsz - pos, "\n");
24834d2c
JS		 173 } else if (!(i & 7)) {
174 pos += scnprintf(buf + pos, bufsz - pos, " ");
175 } else if (!(i & 3)) {
176 pos += scnprintf(buf + pos, bufsz - pos, " ");
177 }
712b6cf5 178 }
24834d2c
JS		 179 if (i)
180 pos += scnprintf(buf + pos, bufsz - pos, "\n");
712b6cf5
TW		 181
182 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2943f136 183 kfree(buf);
712b6cf5
TW		 184 return ret;
185}
186
187static ssize_t iwl_dbgfs_sram_write(struct file *file,
188 const char __user *user_buf,
189 size_t count, loff_t *ppos)
190{
191 struct iwl_priv *priv = file->private_data;
192 char buf[64];
193 int buf_size;
194 u32 offset, len;
195
196 memset(buf, 0, sizeof(buf));
197 buf_size = min(count, sizeof(buf) - 1);
198 if (copy_from_user(buf, user_buf, buf_size))
199 return -EFAULT;
200
201 if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
4c84a8f1
JB		 202 priv->dbgfs_sram_offset = offset;
203 priv->dbgfs_sram_len = len;
24834d2c
JS		 204 } else if (sscanf(buf, "%x", &offset) == 1) {
205 priv->dbgfs_sram_offset = offset;
206 priv->dbgfs_sram_len = -4;
712b6cf5 207 } else {
4c84a8f1
JB		 208 priv->dbgfs_sram_offset = 0;
209 priv->dbgfs_sram_len = 0;
712b6cf5
TW		 210 }
211
212 return count;
213}
214
c8ac61cf
JB		 215static ssize_t iwl_dbgfs_wowlan_sram_read(struct file *file,
216 char __user *user_buf,
217 size_t count, loff_t *ppos)
218{
219 struct iwl_priv *priv = file->private_data;
6dfa8d01 220 const struct fw_img *img = &priv->fw->img[IWL_UCODE_WOWLAN];
c8ac61cf
JB		 221
222 if (!priv->wowlan_sram)
223 return -ENODATA;
224
225 return simple_read_from_buffer(user_buf, count, ppos,
226 priv->wowlan_sram,
6dfa8d01 227 img->sec[IWL_UCODE_SECTION_DATA].len);
c8ac61cf 228}
712b6cf5
TW		 229static ssize_t iwl_dbgfs_stations_read(struct file *file, char __user *user_buf,
230 size_t count, loff_t *ppos)
231{
28f63a4b 232 struct iwl_priv *priv = file->private_data;
6def9761 233 struct iwl_station_entry *station;
5f85a789 234 struct iwl_tid_data *tid_data;
712b6cf5
TW		 235 char *buf;
236 int i, j, pos = 0;
237 ssize_t ret;
238 /* Add 30 for initial string */
239 const size_t bufsz = 30 + sizeof(char) * 500 * (priv->num_stations);
712b6cf5
TW		 240
241 buf = kmalloc(bufsz, GFP_KERNEL);
3ac7f146 242 if (!buf)
712b6cf5
TW		 243 return -ENOMEM;
244
db0589f3 245 pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
712b6cf5
TW		 246 priv->num_stations);
247
3eae4bb1 248 for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
712b6cf5 249 station = &priv->stations[i];
da73511d
JB		 250 if (!station->used)
251 continue;
252 pos += scnprintf(buf + pos, bufsz - pos,
253 "station %d - addr: %pM, flags: %#x\n",
254 i, station->sta.sta.addr,
255 station->sta.station_flags_msk);
256 pos += scnprintf(buf + pos, bufsz - pos,
9eae88fa
JB		 257 "TID seqno next_rclmd "
258 "rate_n_flags state txq\n");
712b6cf5 259
5f85a789 260 for (j = 0; j < IWL_MAX_TID_COUNT; j++) {
04cf6824 261 tid_data = &priv->tid_data[i][j];
da73511d 262 pos += scnprintf(buf + pos, bufsz - pos,
9eae88fa
JB		 263 "%d: 0x%.4x 0x%.4x 0x%.8x "
264 "%d %.2d",
5f85a789 265 j, tid_data->seq_number,
9eae88fa
JB		 266 tid_data->next_reclaimed,
267 tid_data->agg.rate_n_flags,
268 tid_data->agg.state,
269 tid_data->agg.txq_id);
5f85a789
EG		 270
271 if (tid_data->agg.wait_for_ba)
db0589f3 272 pos += scnprintf(buf + pos, bufsz - pos,
da73511d 273 " - waitforba");
db0589f3 274 pos += scnprintf(buf + pos, bufsz - pos, "\n");
712b6cf5 275 }
da73511d
JB		 276
277 pos += scnprintf(buf + pos, bufsz - pos, "\n");
712b6cf5
TW		 278 }
279
280 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
281 kfree(buf);
282 return ret;
283}
284
0848e297 285static ssize_t iwl_dbgfs_nvm_read(struct file *file,
8dd266ef
TW		 286 char __user *user_buf,
287 size_t count,
288 loff_t *ppos)
289{
290 ssize_t ret;
28f63a4b 291 struct iwl_priv *priv = file->private_data;
8dd266ef
TW		 292 int pos = 0, ofs = 0, buf_size = 0;
293 const u8 *ptr;
294 char *buf;
b7998c8b 295 u16 nvm_ver;
26a7ca9a 296 size_t eeprom_len = priv->eeprom_blob_size;
8dd266ef
TW		 297 buf_size = 4 * eeprom_len + 256;
298
f9e75447 299 if (eeprom_len % 16)
8dd266ef 300 return -ENODATA;
8dd266ef 301
26a7ca9a 302 ptr = priv->eeprom_blob;
f9e75447 303 if (!ptr)
c37457e6 304 return -ENOMEM;
c37457e6 305
8dd266ef
TW		 306 /* 4 characters for byte 0xYY */
307 buf = kzalloc(buf_size, GFP_KERNEL);
f9e75447 308 if (!buf)
8dd266ef 309 return -ENOMEM;
f9e75447 310
b7998c8b 311 nvm_ver = priv->nvm_data->nvm_version;
26a7ca9a 312 pos += scnprintf(buf + pos, buf_size - pos,
b7998c8b 313 "NVM version: 0x%x\n", nvm_ver);
8dd266ef 314 for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
3cd6e2f7
AS		 315 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x %16ph\n",
316 ofs, ptr + ofs);
8dd266ef
TW		 317 }
318
319 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
320 kfree(buf);
321 return ret;
322}
712b6cf5 323
d366df5a
WT		 324static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
325 size_t count, loff_t *ppos)
326{
28f63a4b 327 struct iwl_priv *priv = file->private_data;
d366df5a
WT		 328 struct ieee80211_channel *channels = NULL;
329 const struct ieee80211_supported_band *supp_band = NULL;
330 int pos = 0, i, bufsz = PAGE_SIZE;
331 char *buf;
332 ssize_t ret;
333
d366df5a 334 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 335 if (!buf)
d366df5a 336 return -ENOMEM;
d366df5a 337
57fbcce3 338 supp_band = iwl_get_hw_mode(priv, NL80211_BAND_2GHZ);
a2e2322d
WYG		 339 if (supp_band) {
340 channels = supp_band->channels;
d366df5a 341
d366df5a 342 pos += scnprintf(buf + pos, bufsz - pos,
a2e2322d
WYG		 343 "Displaying %d channels in 2.4GHz band 802.11bg):\n",
344 supp_band->n_channels);
d366df5a 345
a2e2322d
WYG		 346 for (i = 0; i < supp_band->n_channels; i++)
347 pos += scnprintf(buf + pos, bufsz - pos,
348 "%d: %ddBm: BSS%s%s, %s.\n",
81e95430 349 channels[i].hw_value,
a2e2322d
WYG		 350 channels[i].max_power,
351 channels[i].flags & IEEE80211_CHAN_RADAR ?
352 " (IEEE 802.11h required)" : "",
8fe02e16 353 ((channels[i].flags & IEEE80211_CHAN_NO_IR)
a2e2322d
WYG		 354 || (channels[i].flags &
355 IEEE80211_CHAN_RADAR)) ? "" :
356 ", IBSS",
357 channels[i].flags &
8fe02e16 358 IEEE80211_CHAN_NO_IR ?
a2e2322d
WYG		 359 "passive only" : "active/passive");
360 }
57fbcce3 361 supp_band = iwl_get_hw_mode(priv, NL80211_BAND_5GHZ);
a2e2322d
WYG		 362 if (supp_band) {
363 channels = supp_band->channels;
d366df5a 364
d366df5a 365 pos += scnprintf(buf + pos, bufsz - pos,
a2e2322d
WYG		 366 "Displaying %d channels in 5.2GHz band (802.11a)\n",
367 supp_band->n_channels);
368
369 for (i = 0; i < supp_band->n_channels; i++)
370 pos += scnprintf(buf + pos, bufsz - pos,
371 "%d: %ddBm: BSS%s%s, %s.\n",
81e95430 372 channels[i].hw_value,
a2e2322d
WYG		 373 channels[i].max_power,
374 channels[i].flags & IEEE80211_CHAN_RADAR ?
375 " (IEEE 802.11h required)" : "",
8fe02e16 376 ((channels[i].flags & IEEE80211_CHAN_NO_IR)
a2e2322d
WYG		 377 || (channels[i].flags &
378 IEEE80211_CHAN_RADAR)) ? "" :
379 ", IBSS",
380 channels[i].flags &
8fe02e16 381 IEEE80211_CHAN_NO_IR ?
a2e2322d
WYG		 382 "passive only" : "active/passive");
383 }
d366df5a
WT		 384 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
385 kfree(buf);
386 return ret;
387}
388
08df05aa
WYG		 389static ssize_t iwl_dbgfs_status_read(struct file *file,
390 char __user *user_buf,
391 size_t count, loff_t *ppos) {
392
28f63a4b 393 struct iwl_priv *priv = file->private_data;
08df05aa
WYG		 394 char buf[512];
395 int pos = 0;
396 const size_t bufsz = sizeof(buf);
397
08df05aa 398 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_RF_KILL_HW:\t %d\n",
83626404 399 test_bit(STATUS_RF_KILL_HW, &priv->status));
7812b167 400 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_CT_KILL:\t\t %d\n",
9a716863 401 test_bit(STATUS_CT_KILL, &priv->status));
08df05aa 402 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_ALIVE:\t\t %d\n",
83626404 403 test_bit(STATUS_ALIVE, &priv->status));
08df05aa 404 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_READY:\t\t %d\n",
83626404 405 test_bit(STATUS_READY, &priv->status));
08df05aa 406 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_EXIT_PENDING:\t %d\n",
83626404 407 test_bit(STATUS_EXIT_PENDING, &priv->status));
08df05aa 408 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_STATISTICS:\t %d\n",
83626404 409 test_bit(STATUS_STATISTICS, &priv->status));
08df05aa 410 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCANNING:\t %d\n",
83626404 411 test_bit(STATUS_SCANNING, &priv->status));
08df05aa 412 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_ABORTING:\t %d\n",
83626404 413 test_bit(STATUS_SCAN_ABORTING, &priv->status));
08df05aa 414 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_HW:\t\t %d\n",
83626404 415 test_bit(STATUS_SCAN_HW, &priv->status));
08df05aa 416 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_POWER_PMI:\t %d\n",
47107e84 417 test_bit(STATUS_POWER_PMI, &priv->status));
08df05aa 418 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_FW_ERROR:\t %d\n",
17acd0b6 419 test_bit(STATUS_FW_ERROR, &priv->status));
08df05aa
WYG		 420 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
421}
422
1f7b6172 423static ssize_t iwl_dbgfs_rx_handlers_read(struct file *file,
a83b9141
WYG		 424 char __user *user_buf,
425 size_t count, loff_t *ppos) {
426
28f63a4b 427 struct iwl_priv *priv = file->private_data;
1f7b6172 428
a83b9141
WYG		 429 int pos = 0;
430 int cnt = 0;
431 char *buf;
432 int bufsz = 24 * 64; /* 24 items * 64 char per item */
433 ssize_t ret;
434
435 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 436 if (!buf)
a83b9141 437 return -ENOMEM;
a83b9141 438
a83b9141 439 for (cnt = 0; cnt < REPLY_MAX; cnt++) {
1f7b6172 440 if (priv->rx_handlers_stats[cnt] > 0)
a83b9141
WYG		 441 pos += scnprintf(buf + pos, bufsz - pos,
442 "\tRx handler[%36s]:\t\t %u\n",
39bdb17e 443 iwl_get_cmd_string(priv->trans, (u32)cnt),
1f7b6172 444 priv->rx_handlers_stats[cnt]);
a83b9141
WYG		 445 }
446
a83b9141
WYG		 447 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
448 kfree(buf);
449 return ret;
450}
451
1f7b6172 452static ssize_t iwl_dbgfs_rx_handlers_write(struct file *file,
a83b9141
WYG		 453 const char __user *user_buf,
454 size_t count, loff_t *ppos)
455{
456 struct iwl_priv *priv = file->private_data;
1f7b6172 457
a83b9141
WYG		 458 char buf[8];
459 int buf_size;
460 u32 reset_flag;
461
462 memset(buf, 0, sizeof(buf));
463 buf_size = min(count, sizeof(buf) - 1);
464 if (copy_from_user(buf, user_buf, buf_size))
465 return -EFAULT;
466 if (sscanf(buf, "%x", &reset_flag) != 1)
467 return -EFAULT;
468 if (reset_flag == 0)
1f7b6172
EG		 469 memset(&priv->rx_handlers_stats[0], 0,
470 sizeof(priv->rx_handlers_stats));
a83b9141
WYG		 471
472 return count;
473}
474
f5ad69fa
WYG		 475static ssize_t iwl_dbgfs_qos_read(struct file *file, char __user *user_buf,
476 size_t count, loff_t *ppos)
477{
28f63a4b 478 struct iwl_priv *priv = file->private_data;
8dfdb9d5 479 struct iwl_rxon_context *ctx;
f5ad69fa 480 int pos = 0, i;
8dfdb9d5 481 char buf[256 * NUM_IWL_RXON_CTX];
f5ad69fa 482 const size_t bufsz = sizeof(buf);
f5ad69fa 483
8dfdb9d5
JB		 484 for_each_context(priv, ctx) {
485 pos += scnprintf(buf + pos, bufsz - pos, "context %d:\n",
486 ctx->ctxid);
487 for (i = 0; i < AC_NUM; i++) {
488 pos += scnprintf(buf + pos, bufsz - pos,
489 "\tcw_min\tcw_max\taifsn\ttxop\n");
490 pos += scnprintf(buf + pos, bufsz - pos,
f5ad69fa 491 "AC[%d]\t%u\t%u\t%u\t%u\n", i,
8dfdb9d5
JB		 492 ctx->qos_data.def_qos_parm.ac[i].cw_min,
493 ctx->qos_data.def_qos_parm.ac[i].cw_max,
494 ctx->qos_data.def_qos_parm.ac[i].aifsn,
495 ctx->qos_data.def_qos_parm.ac[i].edca_txop);
496 }
497 pos += scnprintf(buf + pos, bufsz - pos, "\n");
f5ad69fa 498 }
4967c316 499 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
f5ad69fa 500}
a83b9141 501
fbf3a2af
WYG		 502static ssize_t iwl_dbgfs_thermal_throttling_read(struct file *file,
503 char __user *user_buf,
504 size_t count, loff_t *ppos)
505{
28f63a4b 506 struct iwl_priv *priv = file->private_data;
3ad3b92a 507 struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
fbf3a2af
WYG		 508 struct iwl_tt_restriction *restriction;
509 char buf[100];
510 int pos = 0;
511 const size_t bufsz = sizeof(buf);
fbf3a2af
WYG		 512
513 pos += scnprintf(buf + pos, bufsz - pos,
514 "Thermal Throttling Mode: %s\n",
3ad3b92a 515 tt->advanced_tt ? "Advance" : "Legacy");
fbf3a2af
WYG		 516 pos += scnprintf(buf + pos, bufsz - pos,
517 "Thermal Throttling State: %d\n",
518 tt->state);
3ad3b92a 519 if (tt->advanced_tt) {
fbf3a2af
WYG		 520 restriction = tt->restriction + tt->state;
521 pos += scnprintf(buf + pos, bufsz - pos,
522 "Tx mode: %d\n",
523 restriction->tx_stream);
524 pos += scnprintf(buf + pos, bufsz - pos,
525 "Rx mode: %d\n",
526 restriction->rx_stream);
527 pos += scnprintf(buf + pos, bufsz - pos,
528 "HT mode: %d\n",
529 restriction->is_ht);
530 }
4967c316 531 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
fbf3a2af
WYG		 532}
533
1e4247d4
WYG		 534static ssize_t iwl_dbgfs_disable_ht40_write(struct file *file,
535 const char __user *user_buf,
536 size_t count, loff_t *ppos)
537{
538 struct iwl_priv *priv = file->private_data;
539 char buf[8];
540 int buf_size;
541 int ht40;
542
543 memset(buf, 0, sizeof(buf));
544 buf_size = min(count, sizeof(buf) - 1);
545 if (copy_from_user(buf, user_buf, buf_size))
546 return -EFAULT;
547 if (sscanf(buf, "%d", &ht40) != 1)
548 return -EFAULT;
246ed355 549 if (!iwl_is_any_associated(priv))
1e4247d4 550 priv->disable_ht40 = ht40 ? true : false;
f9e75447 551 else
1e4247d4 552 return -EINVAL;
1e4247d4
WYG		 553
554 return count;
555}
556
557static ssize_t iwl_dbgfs_disable_ht40_read(struct file *file,
558 char __user *user_buf,
559 size_t count, loff_t *ppos)
560{
28f63a4b 561 struct iwl_priv *priv = file->private_data;
1e4247d4
WYG		 562 char buf[100];
563 int pos = 0;
564 const size_t bufsz = sizeof(buf);
1e4247d4
WYG		 565
566 pos += scnprintf(buf + pos, bufsz - pos,
567 "11n 40MHz Mode: %s\n",
568 priv->disable_ht40 ? "Disabled" : "Enabled");
4967c316 569 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1e4247d4
WYG		 570}
571
511afa3b
EG		 572static ssize_t iwl_dbgfs_temperature_read(struct file *file,
573 char __user *user_buf,
574 size_t count, loff_t *ppos)
575{
576 struct iwl_priv *priv = file->private_data;
577 char buf[8];
578 int pos = 0;
579 const size_t bufsz = sizeof(buf);
580
581 pos += scnprintf(buf + pos, bufsz - pos, "%d\n", priv->temperature);
582 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
583}
584
585
e312c24c
JB		 586static ssize_t iwl_dbgfs_sleep_level_override_write(struct file *file,
587 const char __user *user_buf,
588 size_t count, loff_t *ppos)
589{
590 struct iwl_priv *priv = file->private_data;
591 char buf[8];
592 int buf_size;
593 int value;
594
595 memset(buf, 0, sizeof(buf));
596 buf_size = min(count, sizeof(buf) - 1);
597 if (copy_from_user(buf, user_buf, buf_size))
598 return -EFAULT;
599
600 if (sscanf(buf, "%d", &value) != 1)
601 return -EINVAL;
602
603 /*
604 * Our users expect 0 to be "CAM", but 0 isn't actually
605 * valid here. However, let's not confuse them and present
606 * IWL_POWER_INDEX_1 as "1", not "0".
607 */
1a34c043
RC		 608 if (value == 0)
609 return -EINVAL;
610 else if (value > 0)
e312c24c
JB		 611 value -= 1;
612
613 if (value != -1 && (value < 0 || value >= IWL_POWER_NUM))
614 return -EINVAL;
615
83626404 616 if (!iwl_is_ready_rf(priv))
4ad177b5
WYG		 617 return -EAGAIN;
618
e312c24c
JB		 619 priv->power_data.debug_sleep_level_override = value;
620
b1eea297 621 mutex_lock(&priv->mutex);
4ad177b5 622 iwl_power_update_mode(priv, true);
b1eea297 623 mutex_unlock(&priv->mutex);
e312c24c
JB		 624
625 return count;
626}
627
628static ssize_t iwl_dbgfs_sleep_level_override_read(struct file *file,
629 char __user *user_buf,
630 size_t count, loff_t *ppos)
631{
28f63a4b 632 struct iwl_priv *priv = file->private_data;
e312c24c
JB		 633 char buf[10];
634 int pos, value;
635 const size_t bufsz = sizeof(buf);
636
637 /* see the write function */
638 value = priv->power_data.debug_sleep_level_override;
639 if (value >= 0)
640 value += 1;
641
642 pos = scnprintf(buf, bufsz, "%d\n", value);
643 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
644}
645
646static ssize_t iwl_dbgfs_current_sleep_command_read(struct file *file,
647 char __user *user_buf,
648 size_t count, loff_t *ppos)
649{
28f63a4b 650 struct iwl_priv *priv = file->private_data;
e312c24c
JB		 651 char buf[200];
652 int pos = 0, i;
653 const size_t bufsz = sizeof(buf);
654 struct iwl_powertable_cmd *cmd = &priv->power_data.sleep_cmd;
655
656 pos += scnprintf(buf + pos, bufsz - pos,
657 "flags: %#.2x\n", le16_to_cpu(cmd->flags));
658 pos += scnprintf(buf + pos, bufsz - pos,
659 "RX/TX timeout: %d/%d usec\n",
660 le32_to_cpu(cmd->rx_data_timeout),
661 le32_to_cpu(cmd->tx_data_timeout));
662 for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
663 pos += scnprintf(buf + pos, bufsz - pos,
664 "sleep_interval[%d]: %d\n", i,
665 le32_to_cpu(cmd->sleep_interval[i]));
666
667 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
668}
669
712b6cf5 670DEBUGFS_READ_WRITE_FILE_OPS(sram);
c8ac61cf 671DEBUGFS_READ_FILE_OPS(wowlan_sram);
0848e297 672DEBUGFS_READ_FILE_OPS(nvm);
712b6cf5 673DEBUGFS_READ_FILE_OPS(stations);
d366df5a 674DEBUGFS_READ_FILE_OPS(channels);
08df05aa 675DEBUGFS_READ_FILE_OPS(status);
1f7b6172 676DEBUGFS_READ_WRITE_FILE_OPS(rx_handlers);
f5ad69fa 677DEBUGFS_READ_FILE_OPS(qos);
fbf3a2af 678DEBUGFS_READ_FILE_OPS(thermal_throttling);
1e4247d4 679DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40);
511afa3b 680DEBUGFS_READ_FILE_OPS(temperature);
e312c24c
JB		 681DEBUGFS_READ_WRITE_FILE_OPS(sleep_level_override);
682DEBUGFS_READ_FILE_OPS(current_sleep_command);
712b6cf5 683
d6d023a1
WYG		 684static const char *fmt_value = " %-30s %10u\n";
685static const char *fmt_hex = " %-30s 0x%02X\n";
686static const char *fmt_table = " %-30s %10u %10u %10u %10u\n";
687static const char *fmt_header =
688 "%-32s current cumulative delta max\n";
689
690static int iwl_statistics_flag(struct iwl_priv *priv, char *buf, int bufsz)
691{
692 int p = 0;
693 u32 flag;
694
4ff70fcd
JB		 695 lockdep_assert_held(&priv->statistics.lock);
696
d6d023a1
WYG		 697 flag = le32_to_cpu(priv->statistics.flag);
698
699 p += scnprintf(buf + p, bufsz - p, "Statistics Flag(0x%X):\n", flag);
700 if (flag & UCODE_STATISTICS_CLEAR_MSK)
701 p += scnprintf(buf + p, bufsz - p,
702 "\tStatistics have been cleared\n");
703 p += scnprintf(buf + p, bufsz - p, "\tOperational Frequency: %s\n",
704 (flag & UCODE_STATISTICS_FREQUENCY_MSK)
705 ? "2.4 GHz" : "5.2 GHz");
706 p += scnprintf(buf + p, bufsz - p, "\tTGj Narrow Band: %s\n",
707 (flag & UCODE_STATISTICS_NARROW_BAND_MSK)
708 ? "enabled" : "disabled");
709
710 return p;
711}
712
e8fe59ae
WYG		 713static ssize_t iwl_dbgfs_ucode_rx_stats_read(struct file *file,
714 char __user *user_buf,
715 size_t count, loff_t *ppos)
716{
28f63a4b 717 struct iwl_priv *priv = file->private_data;
d6d023a1
WYG		 718 int pos = 0;
719 char *buf;
720 int bufsz = sizeof(struct statistics_rx_phy) * 40 +
721 sizeof(struct statistics_rx_non_phy) * 40 +
722 sizeof(struct statistics_rx_ht_phy) * 40 + 400;
723 ssize_t ret;
724 struct statistics_rx_phy *ofdm, *accum_ofdm, *delta_ofdm, *max_ofdm;
725 struct statistics_rx_phy *cck, *accum_cck, *delta_cck, *max_cck;
726 struct statistics_rx_non_phy *general, *accum_general;
727 struct statistics_rx_non_phy *delta_general, *max_general;
728 struct statistics_rx_ht_phy *ht, *accum_ht, *delta_ht, *max_ht;
729
83626404 730 if (!iwl_is_alive(priv))
d6d023a1
WYG		 731 return -EAGAIN;
732
733 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 734 if (!buf)
d6d023a1 735 return -ENOMEM;
d6d023a1
WYG		 736
737 /*
738 * the statistic information display here is based on
739 * the last statistics notification from uCode
740 * might not reflect the current uCode activity
741 */
4ff70fcd 742 spin_lock_bh(&priv->statistics.lock);
d6d023a1
WYG		 743 ofdm = &priv->statistics.rx_ofdm;
744 cck = &priv->statistics.rx_cck;
745 general = &priv->statistics.rx_non_phy;
746 ht = &priv->statistics.rx_ofdm_ht;
747 accum_ofdm = &priv->accum_stats.rx_ofdm;
748 accum_cck = &priv->accum_stats.rx_cck;
749 accum_general = &priv->accum_stats.rx_non_phy;
750 accum_ht = &priv->accum_stats.rx_ofdm_ht;
751 delta_ofdm = &priv->delta_stats.rx_ofdm;
752 delta_cck = &priv->delta_stats.rx_cck;
753 delta_general = &priv->delta_stats.rx_non_phy;
754 delta_ht = &priv->delta_stats.rx_ofdm_ht;
755 max_ofdm = &priv->max_delta_stats.rx_ofdm;
756 max_cck = &priv->max_delta_stats.rx_cck;
757 max_general = &priv->max_delta_stats.rx_non_phy;
758 max_ht = &priv->max_delta_stats.rx_ofdm_ht;
759
760 pos += iwl_statistics_flag(priv, buf, bufsz);
761 pos += scnprintf(buf + pos, bufsz - pos,
762 fmt_header, "Statistics_Rx - OFDM:");
763 pos += scnprintf(buf + pos, bufsz - pos,
764 fmt_table, "ina_cnt:",
765 le32_to_cpu(ofdm->ina_cnt),
766 accum_ofdm->ina_cnt,
767 delta_ofdm->ina_cnt, max_ofdm->ina_cnt);
768 pos += scnprintf(buf + pos, bufsz - pos,
769 fmt_table, "fina_cnt:",
770 le32_to_cpu(ofdm->fina_cnt), accum_ofdm->fina_cnt,
771 delta_ofdm->fina_cnt, max_ofdm->fina_cnt);
772 pos += scnprintf(buf + pos, bufsz - pos,
773 fmt_table, "plcp_err:",
774 le32_to_cpu(ofdm->plcp_err), accum_ofdm->plcp_err,
775 delta_ofdm->plcp_err, max_ofdm->plcp_err);
776 pos += scnprintf(buf + pos, bufsz - pos,
777 fmt_table, "crc32_err:",
778 le32_to_cpu(ofdm->crc32_err), accum_ofdm->crc32_err,
779 delta_ofdm->crc32_err, max_ofdm->crc32_err);
780 pos += scnprintf(buf + pos, bufsz - pos,
781 fmt_table, "overrun_err:",
782 le32_to_cpu(ofdm->overrun_err),
783 accum_ofdm->overrun_err, delta_ofdm->overrun_err,
784 max_ofdm->overrun_err);
785 pos += scnprintf(buf + pos, bufsz - pos,
786 fmt_table, "early_overrun_err:",
787 le32_to_cpu(ofdm->early_overrun_err),
788 accum_ofdm->early_overrun_err,
789 delta_ofdm->early_overrun_err,
790 max_ofdm->early_overrun_err);
791 pos += scnprintf(buf + pos, bufsz - pos,
792 fmt_table, "crc32_good:",
793 le32_to_cpu(ofdm->crc32_good),
794 accum_ofdm->crc32_good, delta_ofdm->crc32_good,
795 max_ofdm->crc32_good);
796 pos += scnprintf(buf + pos, bufsz - pos,
797 fmt_table, "false_alarm_cnt:",
798 le32_to_cpu(ofdm->false_alarm_cnt),
799 accum_ofdm->false_alarm_cnt,
800 delta_ofdm->false_alarm_cnt,
801 max_ofdm->false_alarm_cnt);
802 pos += scnprintf(buf + pos, bufsz - pos,
803 fmt_table, "fina_sync_err_cnt:",
804 le32_to_cpu(ofdm->fina_sync_err_cnt),
805 accum_ofdm->fina_sync_err_cnt,
806 delta_ofdm->fina_sync_err_cnt,
807 max_ofdm->fina_sync_err_cnt);
808 pos += scnprintf(buf + pos, bufsz - pos,
809 fmt_table, "sfd_timeout:",
810 le32_to_cpu(ofdm->sfd_timeout),
811 accum_ofdm->sfd_timeout, delta_ofdm->sfd_timeout,
812 max_ofdm->sfd_timeout);
813 pos += scnprintf(buf + pos, bufsz - pos,
814 fmt_table, "fina_timeout:",
815 le32_to_cpu(ofdm->fina_timeout),
816 accum_ofdm->fina_timeout, delta_ofdm->fina_timeout,
817 max_ofdm->fina_timeout);
818 pos += scnprintf(buf + pos, bufsz - pos,
819 fmt_table, "unresponded_rts:",
820 le32_to_cpu(ofdm->unresponded_rts),
821 accum_ofdm->unresponded_rts,
822 delta_ofdm->unresponded_rts,
823 max_ofdm->unresponded_rts);
824 pos += scnprintf(buf + pos, bufsz - pos,
825 fmt_table, "rxe_frame_lmt_ovrun:",
826 le32_to_cpu(ofdm->rxe_frame_limit_overrun),
827 accum_ofdm->rxe_frame_limit_overrun,
828 delta_ofdm->rxe_frame_limit_overrun,
829 max_ofdm->rxe_frame_limit_overrun);
830 pos += scnprintf(buf + pos, bufsz - pos,
831 fmt_table, "sent_ack_cnt:",
832 le32_to_cpu(ofdm->sent_ack_cnt),
833 accum_ofdm->sent_ack_cnt, delta_ofdm->sent_ack_cnt,
834 max_ofdm->sent_ack_cnt);
835 pos += scnprintf(buf + pos, bufsz - pos,
836 fmt_table, "sent_cts_cnt:",
837 le32_to_cpu(ofdm->sent_cts_cnt),
838 accum_ofdm->sent_cts_cnt, delta_ofdm->sent_cts_cnt,
839 max_ofdm->sent_cts_cnt);
840 pos += scnprintf(buf + pos, bufsz - pos,
841 fmt_table, "sent_ba_rsp_cnt:",
842 le32_to_cpu(ofdm->sent_ba_rsp_cnt),
843 accum_ofdm->sent_ba_rsp_cnt,
844 delta_ofdm->sent_ba_rsp_cnt,
845 max_ofdm->sent_ba_rsp_cnt);
846 pos += scnprintf(buf + pos, bufsz - pos,
847 fmt_table, "dsp_self_kill:",
848 le32_to_cpu(ofdm->dsp_self_kill),
849 accum_ofdm->dsp_self_kill,
850 delta_ofdm->dsp_self_kill,
851 max_ofdm->dsp_self_kill);
852 pos += scnprintf(buf + pos, bufsz - pos,
853 fmt_table, "mh_format_err:",
854 le32_to_cpu(ofdm->mh_format_err),
855 accum_ofdm->mh_format_err,
856 delta_ofdm->mh_format_err,
857 max_ofdm->mh_format_err);
858 pos += scnprintf(buf + pos, bufsz - pos,
859 fmt_table, "re_acq_main_rssi_sum:",
860 le32_to_cpu(ofdm->re_acq_main_rssi_sum),
861 accum_ofdm->re_acq_main_rssi_sum,
862 delta_ofdm->re_acq_main_rssi_sum,
863 max_ofdm->re_acq_main_rssi_sum);
864
865 pos += scnprintf(buf + pos, bufsz - pos,
866 fmt_header, "Statistics_Rx - CCK:");
867 pos += scnprintf(buf + pos, bufsz - pos,
868 fmt_table, "ina_cnt:",
869 le32_to_cpu(cck->ina_cnt), accum_cck->ina_cnt,
870 delta_cck->ina_cnt, max_cck->ina_cnt);
871 pos += scnprintf(buf + pos, bufsz - pos,
872 fmt_table, "fina_cnt:",
873 le32_to_cpu(cck->fina_cnt), accum_cck->fina_cnt,
874 delta_cck->fina_cnt, max_cck->fina_cnt);
875 pos += scnprintf(buf + pos, bufsz - pos,
876 fmt_table, "plcp_err:",
877 le32_to_cpu(cck->plcp_err), accum_cck->plcp_err,
878 delta_cck->plcp_err, max_cck->plcp_err);
879 pos += scnprintf(buf + pos, bufsz - pos,
880 fmt_table, "crc32_err:",
881 le32_to_cpu(cck->crc32_err), accum_cck->crc32_err,
882 delta_cck->crc32_err, max_cck->crc32_err);
883 pos += scnprintf(buf + pos, bufsz - pos,
884 fmt_table, "overrun_err:",
885 le32_to_cpu(cck->overrun_err),
886 accum_cck->overrun_err, delta_cck->overrun_err,
887 max_cck->overrun_err);
888 pos += scnprintf(buf + pos, bufsz - pos,
889 fmt_table, "early_overrun_err:",
890 le32_to_cpu(cck->early_overrun_err),
891 accum_cck->early_overrun_err,
892 delta_cck->early_overrun_err,
893 max_cck->early_overrun_err);
894 pos += scnprintf(buf + pos, bufsz - pos,
895 fmt_table, "crc32_good:",
896 le32_to_cpu(cck->crc32_good), accum_cck->crc32_good,
897 delta_cck->crc32_good, max_cck->crc32_good);
898 pos += scnprintf(buf + pos, bufsz - pos,
899 fmt_table, "false_alarm_cnt:",
900 le32_to_cpu(cck->false_alarm_cnt),
901 accum_cck->false_alarm_cnt,
902 delta_cck->false_alarm_cnt, max_cck->false_alarm_cnt);
903 pos += scnprintf(buf + pos, bufsz - pos,
904 fmt_table, "fina_sync_err_cnt:",
905 le32_to_cpu(cck->fina_sync_err_cnt),
906 accum_cck->fina_sync_err_cnt,
907 delta_cck->fina_sync_err_cnt,
908 max_cck->fina_sync_err_cnt);
909 pos += scnprintf(buf + pos, bufsz - pos,
910 fmt_table, "sfd_timeout:",
911 le32_to_cpu(cck->sfd_timeout),
912 accum_cck->sfd_timeout, delta_cck->sfd_timeout,
913 max_cck->sfd_timeout);
914 pos += scnprintf(buf + pos, bufsz - pos,
915 fmt_table, "fina_timeout:",
916 le32_to_cpu(cck->fina_timeout),
917 accum_cck->fina_timeout, delta_cck->fina_timeout,
918 max_cck->fina_timeout);
919 pos += scnprintf(buf + pos, bufsz - pos,
920 fmt_table, "unresponded_rts:",
921 le32_to_cpu(cck->unresponded_rts),
922 accum_cck->unresponded_rts, delta_cck->unresponded_rts,
923 max_cck->unresponded_rts);
924 pos += scnprintf(buf + pos, bufsz - pos,
925 fmt_table, "rxe_frame_lmt_ovrun:",
926 le32_to_cpu(cck->rxe_frame_limit_overrun),
927 accum_cck->rxe_frame_limit_overrun,
928 delta_cck->rxe_frame_limit_overrun,
929 max_cck->rxe_frame_limit_overrun);
930 pos += scnprintf(buf + pos, bufsz - pos,
931 fmt_table, "sent_ack_cnt:",
932 le32_to_cpu(cck->sent_ack_cnt),
933 accum_cck->sent_ack_cnt, delta_cck->sent_ack_cnt,
934 max_cck->sent_ack_cnt);
935 pos += scnprintf(buf + pos, bufsz - pos,
936 fmt_table, "sent_cts_cnt:",
937 le32_to_cpu(cck->sent_cts_cnt),
938 accum_cck->sent_cts_cnt, delta_cck->sent_cts_cnt,
939 max_cck->sent_cts_cnt);
940 pos += scnprintf(buf + pos, bufsz - pos,
941 fmt_table, "sent_ba_rsp_cnt:",
942 le32_to_cpu(cck->sent_ba_rsp_cnt),
943 accum_cck->sent_ba_rsp_cnt,
944 delta_cck->sent_ba_rsp_cnt,
945 max_cck->sent_ba_rsp_cnt);
946 pos += scnprintf(buf + pos, bufsz - pos,
947 fmt_table, "dsp_self_kill:",
948 le32_to_cpu(cck->dsp_self_kill),
949 accum_cck->dsp_self_kill, delta_cck->dsp_self_kill,
950 max_cck->dsp_self_kill);
951 pos += scnprintf(buf + pos, bufsz - pos,
952 fmt_table, "mh_format_err:",
953 le32_to_cpu(cck->mh_format_err),
954 accum_cck->mh_format_err, delta_cck->mh_format_err,
955 max_cck->mh_format_err);
956 pos += scnprintf(buf + pos, bufsz - pos,
957 fmt_table, "re_acq_main_rssi_sum:",
958 le32_to_cpu(cck->re_acq_main_rssi_sum),
959 accum_cck->re_acq_main_rssi_sum,
960 delta_cck->re_acq_main_rssi_sum,
961 max_cck->re_acq_main_rssi_sum);
962
963 pos += scnprintf(buf + pos, bufsz - pos,
964 fmt_header, "Statistics_Rx - GENERAL:");
965 pos += scnprintf(buf + pos, bufsz - pos,
966 fmt_table, "bogus_cts:",
967 le32_to_cpu(general->bogus_cts),
968 accum_general->bogus_cts, delta_general->bogus_cts,
969 max_general->bogus_cts);
970 pos += scnprintf(buf + pos, bufsz - pos,
971 fmt_table, "bogus_ack:",
972 le32_to_cpu(general->bogus_ack),
973 accum_general->bogus_ack, delta_general->bogus_ack,
974 max_general->bogus_ack);
975 pos += scnprintf(buf + pos, bufsz - pos,
976 fmt_table, "non_bssid_frames:",
977 le32_to_cpu(general->non_bssid_frames),
978 accum_general->non_bssid_frames,
979 delta_general->non_bssid_frames,
980 max_general->non_bssid_frames);
981 pos += scnprintf(buf + pos, bufsz - pos,
982 fmt_table, "filtered_frames:",
983 le32_to_cpu(general->filtered_frames),
984 accum_general->filtered_frames,
985 delta_general->filtered_frames,
986 max_general->filtered_frames);
987 pos += scnprintf(buf + pos, bufsz - pos,
988 fmt_table, "non_channel_beacons:",
989 le32_to_cpu(general->non_channel_beacons),
990 accum_general->non_channel_beacons,
991 delta_general->non_channel_beacons,
992 max_general->non_channel_beacons);
993 pos += scnprintf(buf + pos, bufsz - pos,
994 fmt_table, "channel_beacons:",
995 le32_to_cpu(general->channel_beacons),
996 accum_general->channel_beacons,
997 delta_general->channel_beacons,
998 max_general->channel_beacons);
999 pos += scnprintf(buf + pos, bufsz - pos,
1000 fmt_table, "num_missed_bcon:",
1001 le32_to_cpu(general->num_missed_bcon),
1002 accum_general->num_missed_bcon,
1003 delta_general->num_missed_bcon,
1004 max_general->num_missed_bcon);
1005 pos += scnprintf(buf + pos, bufsz - pos,
1006 fmt_table, "adc_rx_saturation_time:",
1007 le32_to_cpu(general->adc_rx_saturation_time),
1008 accum_general->adc_rx_saturation_time,
1009 delta_general->adc_rx_saturation_time,
1010 max_general->adc_rx_saturation_time);
1011 pos += scnprintf(buf + pos, bufsz - pos,
1012 fmt_table, "ina_detect_search_tm:",
1013 le32_to_cpu(general->ina_detection_search_time),
1014 accum_general->ina_detection_search_time,
1015 delta_general->ina_detection_search_time,
1016 max_general->ina_detection_search_time);
1017 pos += scnprintf(buf + pos, bufsz - pos,
1018 fmt_table, "beacon_silence_rssi_a:",
1019 le32_to_cpu(general->beacon_silence_rssi_a),
1020 accum_general->beacon_silence_rssi_a,
1021 delta_general->beacon_silence_rssi_a,
1022 max_general->beacon_silence_rssi_a);
1023 pos += scnprintf(buf + pos, bufsz - pos,
1024 fmt_table, "beacon_silence_rssi_b:",
1025 le32_to_cpu(general->beacon_silence_rssi_b),
1026 accum_general->beacon_silence_rssi_b,
1027 delta_general->beacon_silence_rssi_b,
1028 max_general->beacon_silence_rssi_b);
1029 pos += scnprintf(buf + pos, bufsz - pos,
1030 fmt_table, "beacon_silence_rssi_c:",
1031 le32_to_cpu(general->beacon_silence_rssi_c),
1032 accum_general->beacon_silence_rssi_c,
1033 delta_general->beacon_silence_rssi_c,
1034 max_general->beacon_silence_rssi_c);
1035 pos += scnprintf(buf + pos, bufsz - pos,
1036 fmt_table, "interference_data_flag:",
1037 le32_to_cpu(general->interference_data_flag),
1038 accum_general->interference_data_flag,
1039 delta_general->interference_data_flag,
1040 max_general->interference_data_flag);
1041 pos += scnprintf(buf + pos, bufsz - pos,
1042 fmt_table, "channel_load:",
1043 le32_to_cpu(general->channel_load),
1044 accum_general->channel_load,
1045 delta_general->channel_load,
1046 max_general->channel_load);
1047 pos += scnprintf(buf + pos, bufsz - pos,
1048 fmt_table, "dsp_false_alarms:",
1049 le32_to_cpu(general->dsp_false_alarms),
1050 accum_general->dsp_false_alarms,
1051 delta_general->dsp_false_alarms,
1052 max_general->dsp_false_alarms);
1053 pos += scnprintf(buf + pos, bufsz - pos,
1054 fmt_table, "beacon_rssi_a:",
1055 le32_to_cpu(general->beacon_rssi_a),
1056 accum_general->beacon_rssi_a,
1057 delta_general->beacon_rssi_a,
1058 max_general->beacon_rssi_a);
1059 pos += scnprintf(buf + pos, bufsz - pos,
1060 fmt_table, "beacon_rssi_b:",
1061 le32_to_cpu(general->beacon_rssi_b),
1062 accum_general->beacon_rssi_b,
1063 delta_general->beacon_rssi_b,
1064 max_general->beacon_rssi_b);
1065 pos += scnprintf(buf + pos, bufsz - pos,
1066 fmt_table, "beacon_rssi_c:",
1067 le32_to_cpu(general->beacon_rssi_c),
1068 accum_general->beacon_rssi_c,
1069 delta_general->beacon_rssi_c,
1070 max_general->beacon_rssi_c);
1071 pos += scnprintf(buf + pos, bufsz - pos,
1072 fmt_table, "beacon_energy_a:",
1073 le32_to_cpu(general->beacon_energy_a),
1074 accum_general->beacon_energy_a,
1075 delta_general->beacon_energy_a,
1076 max_general->beacon_energy_a);
1077 pos += scnprintf(buf + pos, bufsz - pos,
1078 fmt_table, "beacon_energy_b:",
1079 le32_to_cpu(general->beacon_energy_b),
1080 accum_general->beacon_energy_b,
1081 delta_general->beacon_energy_b,
1082 max_general->beacon_energy_b);
1083 pos += scnprintf(buf + pos, bufsz - pos,
1084 fmt_table, "beacon_energy_c:",
1085 le32_to_cpu(general->beacon_energy_c),
1086 accum_general->beacon_energy_c,
1087 delta_general->beacon_energy_c,
1088 max_general->beacon_energy_c);
1089
1090 pos += scnprintf(buf + pos, bufsz - pos,
1091 fmt_header, "Statistics_Rx - OFDM_HT:");
1092 pos += scnprintf(buf + pos, bufsz - pos,
1093 fmt_table, "plcp_err:",
1094 le32_to_cpu(ht->plcp_err), accum_ht->plcp_err,
1095 delta_ht->plcp_err, max_ht->plcp_err);
1096 pos += scnprintf(buf + pos, bufsz - pos,
1097 fmt_table, "overrun_err:",
1098 le32_to_cpu(ht->overrun_err), accum_ht->overrun_err,
1099 delta_ht->overrun_err, max_ht->overrun_err);
1100 pos += scnprintf(buf + pos, bufsz - pos,
1101 fmt_table, "early_overrun_err:",
1102 le32_to_cpu(ht->early_overrun_err),
1103 accum_ht->early_overrun_err,
1104 delta_ht->early_overrun_err,
1105 max_ht->early_overrun_err);
1106 pos += scnprintf(buf + pos, bufsz - pos,
1107 fmt_table, "crc32_good:",
1108 le32_to_cpu(ht->crc32_good), accum_ht->crc32_good,
1109 delta_ht->crc32_good, max_ht->crc32_good);
1110 pos += scnprintf(buf + pos, bufsz - pos,
1111 fmt_table, "crc32_err:",
1112 le32_to_cpu(ht->crc32_err), accum_ht->crc32_err,
1113 delta_ht->crc32_err, max_ht->crc32_err);
1114 pos += scnprintf(buf + pos, bufsz - pos,
1115 fmt_table, "mh_format_err:",
1116 le32_to_cpu(ht->mh_format_err),
1117 accum_ht->mh_format_err,
1118 delta_ht->mh_format_err, max_ht->mh_format_err);
1119 pos += scnprintf(buf + pos, bufsz - pos,
1120 fmt_table, "agg_crc32_good:",
1121 le32_to_cpu(ht->agg_crc32_good),
1122 accum_ht->agg_crc32_good,
1123 delta_ht->agg_crc32_good, max_ht->agg_crc32_good);
1124 pos += scnprintf(buf + pos, bufsz - pos,
1125 fmt_table, "agg_mpdu_cnt:",
1126 le32_to_cpu(ht->agg_mpdu_cnt),
1127 accum_ht->agg_mpdu_cnt,
1128 delta_ht->agg_mpdu_cnt, max_ht->agg_mpdu_cnt);
1129 pos += scnprintf(buf + pos, bufsz - pos,
1130 fmt_table, "agg_cnt:",
1131 le32_to_cpu(ht->agg_cnt), accum_ht->agg_cnt,
1132 delta_ht->agg_cnt, max_ht->agg_cnt);
1133 pos += scnprintf(buf + pos, bufsz - pos,
1134 fmt_table, "unsupport_mcs:",
1135 le32_to_cpu(ht->unsupport_mcs),
1136 accum_ht->unsupport_mcs,
1137 delta_ht->unsupport_mcs, max_ht->unsupport_mcs);
1138
4ff70fcd
JB		 1139 spin_unlock_bh(&priv->statistics.lock);
1140
d6d023a1
WYG		 1141 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1142 kfree(buf);
1143 return ret;
e8fe59ae
WYG		 1144}
1145
1146static ssize_t iwl_dbgfs_ucode_tx_stats_read(struct file *file,
1147 char __user *user_buf,
1148 size_t count, loff_t *ppos)
1149{
28f63a4b 1150 struct iwl_priv *priv = file->private_data;
d6d023a1
WYG		 1151 int pos = 0;
1152 char *buf;
1153 int bufsz = (sizeof(struct statistics_tx) * 48) + 250;
1154 ssize_t ret;
1155 struct statistics_tx *tx, *accum_tx, *delta_tx, *max_tx;
1156
83626404 1157 if (!iwl_is_alive(priv))
d6d023a1
WYG		 1158 return -EAGAIN;
1159
1160 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 1161 if (!buf)
d6d023a1 1162 return -ENOMEM;
d6d023a1
WYG		 1163
1164 /* the statistic information display here is based on
1165 * the last statistics notification from uCode
1166 * might not reflect the current uCode activity
1167 */
4ff70fcd
JB		 1168 spin_lock_bh(&priv->statistics.lock);
1169
d6d023a1
WYG		 1170 tx = &priv->statistics.tx;
1171 accum_tx = &priv->accum_stats.tx;
1172 delta_tx = &priv->delta_stats.tx;
1173 max_tx = &priv->max_delta_stats.tx;
1174
1175 pos += iwl_statistics_flag(priv, buf, bufsz);
1176 pos += scnprintf(buf + pos, bufsz - pos,
1177 fmt_header, "Statistics_Tx:");
1178 pos += scnprintf(buf + pos, bufsz - pos,
1179 fmt_table, "preamble:",
1180 le32_to_cpu(tx->preamble_cnt),
1181 accum_tx->preamble_cnt,
1182 delta_tx->preamble_cnt, max_tx->preamble_cnt);
1183 pos += scnprintf(buf + pos, bufsz - pos,
1184 fmt_table, "rx_detected_cnt:",
1185 le32_to_cpu(tx->rx_detected_cnt),
1186 accum_tx->rx_detected_cnt,
1187 delta_tx->rx_detected_cnt, max_tx->rx_detected_cnt);
1188 pos += scnprintf(buf + pos, bufsz - pos,
1189 fmt_table, "bt_prio_defer_cnt:",
1190 le32_to_cpu(tx->bt_prio_defer_cnt),
1191 accum_tx->bt_prio_defer_cnt,
1192 delta_tx->bt_prio_defer_cnt,
1193 max_tx->bt_prio_defer_cnt);
1194 pos += scnprintf(buf + pos, bufsz - pos,
1195 fmt_table, "bt_prio_kill_cnt:",
1196 le32_to_cpu(tx->bt_prio_kill_cnt),
1197 accum_tx->bt_prio_kill_cnt,
1198 delta_tx->bt_prio_kill_cnt,
1199 max_tx->bt_prio_kill_cnt);
1200 pos += scnprintf(buf + pos, bufsz - pos,
1201 fmt_table, "few_bytes_cnt:",
1202 le32_to_cpu(tx->few_bytes_cnt),
1203 accum_tx->few_bytes_cnt,
1204 delta_tx->few_bytes_cnt, max_tx->few_bytes_cnt);
1205 pos += scnprintf(buf + pos, bufsz - pos,
1206 fmt_table, "cts_timeout:",
1207 le32_to_cpu(tx->cts_timeout), accum_tx->cts_timeout,
1208 delta_tx->cts_timeout, max_tx->cts_timeout);
1209 pos += scnprintf(buf + pos, bufsz - pos,
1210 fmt_table, "ack_timeout:",
1211 le32_to_cpu(tx->ack_timeout),
1212 accum_tx->ack_timeout,
1213 delta_tx->ack_timeout, max_tx->ack_timeout);
1214 pos += scnprintf(buf + pos, bufsz - pos,
1215 fmt_table, "expected_ack_cnt:",
1216 le32_to_cpu(tx->expected_ack_cnt),
1217 accum_tx->expected_ack_cnt,
1218 delta_tx->expected_ack_cnt,
1219 max_tx->expected_ack_cnt);
1220 pos += scnprintf(buf + pos, bufsz - pos,
1221 fmt_table, "actual_ack_cnt:",
1222 le32_to_cpu(tx->actual_ack_cnt),
1223 accum_tx->actual_ack_cnt,
1224 delta_tx->actual_ack_cnt,
1225 max_tx->actual_ack_cnt);
1226 pos += scnprintf(buf + pos, bufsz - pos,
1227 fmt_table, "dump_msdu_cnt:",
1228 le32_to_cpu(tx->dump_msdu_cnt),
1229 accum_tx->dump_msdu_cnt,
1230 delta_tx->dump_msdu_cnt,
1231 max_tx->dump_msdu_cnt);
1232 pos += scnprintf(buf + pos, bufsz - pos,
1233 fmt_table, "abort_nxt_frame_mismatch:",
1234 le32_to_cpu(tx->burst_abort_next_frame_mismatch_cnt),
1235 accum_tx->burst_abort_next_frame_mismatch_cnt,
1236 delta_tx->burst_abort_next_frame_mismatch_cnt,
1237 max_tx->burst_abort_next_frame_mismatch_cnt);
1238 pos += scnprintf(buf + pos, bufsz - pos,
1239 fmt_table, "abort_missing_nxt_frame:",
1240 le32_to_cpu(tx->burst_abort_missing_next_frame_cnt),
1241 accum_tx->burst_abort_missing_next_frame_cnt,
1242 delta_tx->burst_abort_missing_next_frame_cnt,
1243 max_tx->burst_abort_missing_next_frame_cnt);
1244 pos += scnprintf(buf + pos, bufsz - pos,
1245 fmt_table, "cts_timeout_collision:",
1246 le32_to_cpu(tx->cts_timeout_collision),
1247 accum_tx->cts_timeout_collision,
1248 delta_tx->cts_timeout_collision,
1249 max_tx->cts_timeout_collision);
1250 pos += scnprintf(buf + pos, bufsz - pos,
1251 fmt_table, "ack_ba_timeout_collision:",
1252 le32_to_cpu(tx->ack_or_ba_timeout_collision),
1253 accum_tx->ack_or_ba_timeout_collision,
1254 delta_tx->ack_or_ba_timeout_collision,
1255 max_tx->ack_or_ba_timeout_collision);
1256 pos += scnprintf(buf + pos, bufsz - pos,
1257 fmt_table, "agg ba_timeout:",
1258 le32_to_cpu(tx->agg.ba_timeout),
1259 accum_tx->agg.ba_timeout,
1260 delta_tx->agg.ba_timeout,
1261 max_tx->agg.ba_timeout);
1262 pos += scnprintf(buf + pos, bufsz - pos,
1263 fmt_table, "agg ba_resched_frames:",
1264 le32_to_cpu(tx->agg.ba_reschedule_frames),
1265 accum_tx->agg.ba_reschedule_frames,
1266 delta_tx->agg.ba_reschedule_frames,
1267 max_tx->agg.ba_reschedule_frames);
1268 pos += scnprintf(buf + pos, bufsz - pos,
1269 fmt_table, "agg scd_query_agg_frame:",
1270 le32_to_cpu(tx->agg.scd_query_agg_frame_cnt),
1271 accum_tx->agg.scd_query_agg_frame_cnt,
1272 delta_tx->agg.scd_query_agg_frame_cnt,
1273 max_tx->agg.scd_query_agg_frame_cnt);
1274 pos += scnprintf(buf + pos, bufsz - pos,
1275 fmt_table, "agg scd_query_no_agg:",
1276 le32_to_cpu(tx->agg.scd_query_no_agg),
1277 accum_tx->agg.scd_query_no_agg,
1278 delta_tx->agg.scd_query_no_agg,
1279 max_tx->agg.scd_query_no_agg);
1280 pos += scnprintf(buf + pos, bufsz - pos,
1281 fmt_table, "agg scd_query_agg:",
1282 le32_to_cpu(tx->agg.scd_query_agg),
1283 accum_tx->agg.scd_query_agg,
1284 delta_tx->agg.scd_query_agg,
1285 max_tx->agg.scd_query_agg);
1286 pos += scnprintf(buf + pos, bufsz - pos,
1287 fmt_table, "agg scd_query_mismatch:",
1288 le32_to_cpu(tx->agg.scd_query_mismatch),
1289 accum_tx->agg.scd_query_mismatch,
1290 delta_tx->agg.scd_query_mismatch,
1291 max_tx->agg.scd_query_mismatch);
1292 pos += scnprintf(buf + pos, bufsz - pos,
1293 fmt_table, "agg frame_not_ready:",
1294 le32_to_cpu(tx->agg.frame_not_ready),
1295 accum_tx->agg.frame_not_ready,
1296 delta_tx->agg.frame_not_ready,
1297 max_tx->agg.frame_not_ready);
1298 pos += scnprintf(buf + pos, bufsz - pos,
1299 fmt_table, "agg underrun:",
1300 le32_to_cpu(tx->agg.underrun),
1301 accum_tx->agg.underrun,
1302 delta_tx->agg.underrun, max_tx->agg.underrun);
1303 pos += scnprintf(buf + pos, bufsz - pos,
1304 fmt_table, "agg bt_prio_kill:",
1305 le32_to_cpu(tx->agg.bt_prio_kill),
1306 accum_tx->agg.bt_prio_kill,
1307 delta_tx->agg.bt_prio_kill,
1308 max_tx->agg.bt_prio_kill);
1309 pos += scnprintf(buf + pos, bufsz - pos,
1310 fmt_table, "agg rx_ba_rsp_cnt:",
1311 le32_to_cpu(tx->agg.rx_ba_rsp_cnt),
1312 accum_tx->agg.rx_ba_rsp_cnt,
1313 delta_tx->agg.rx_ba_rsp_cnt,
1314 max_tx->agg.rx_ba_rsp_cnt);
1315
1316 if (tx->tx_power.ant_a || tx->tx_power.ant_b || tx->tx_power.ant_c) {
1317 pos += scnprintf(buf + pos, bufsz - pos,
1318 "tx power: (1/2 dB step)\n");
b7998c8b 1319 if ((priv->nvm_data->valid_tx_ant & ANT_A) &&
7e79a393 1320 tx->tx_power.ant_a)
d6d023a1
WYG		 1321 pos += scnprintf(buf + pos, bufsz - pos,
1322 fmt_hex, "antenna A:",
1323 tx->tx_power.ant_a);
b7998c8b 1324 if ((priv->nvm_data->valid_tx_ant & ANT_B) &&
7e79a393 1325 tx->tx_power.ant_b)
d6d023a1
WYG		 1326 pos += scnprintf(buf + pos, bufsz - pos,
1327 fmt_hex, "antenna B:",
1328 tx->tx_power.ant_b);
b7998c8b 1329 if ((priv->nvm_data->valid_tx_ant & ANT_C) &&
7e79a393 1330 tx->tx_power.ant_c)
d6d023a1
WYG		 1331 pos += scnprintf(buf + pos, bufsz - pos,
1332 fmt_hex, "antenna C:",
1333 tx->tx_power.ant_c);
1334 }
4ff70fcd
JB		 1335
1336 spin_unlock_bh(&priv->statistics.lock);
1337
d6d023a1
WYG		 1338 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1339 kfree(buf);
1340 return ret;
e8fe59ae
WYG		 1341}
1342
1343static ssize_t iwl_dbgfs_ucode_general_stats_read(struct file *file,
1344 char __user *user_buf,
1345 size_t count, loff_t *ppos)
1346{
28f63a4b 1347 struct iwl_priv *priv = file->private_data;
d6d023a1
WYG		 1348 int pos = 0;
1349 char *buf;
1350 int bufsz = sizeof(struct statistics_general) * 10 + 300;
1351 ssize_t ret;
1352 struct statistics_general_common *general, *accum_general;
1353 struct statistics_general_common *delta_general, *max_general;
1354 struct statistics_dbg *dbg, *accum_dbg, *delta_dbg, *max_dbg;
1355 struct statistics_div *div, *accum_div, *delta_div, *max_div;
1356
83626404 1357 if (!iwl_is_alive(priv))
d6d023a1
WYG		 1358 return -EAGAIN;
1359
1360 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 1361 if (!buf)
d6d023a1 1362 return -ENOMEM;
d6d023a1
WYG		 1363
1364 /* the statistic information display here is based on
1365 * the last statistics notification from uCode
1366 * might not reflect the current uCode activity
1367 */
4ff70fcd
JB		 1368
1369 spin_lock_bh(&priv->statistics.lock);
1370
d6d023a1
WYG		 1371 general = &priv->statistics.common;
1372 dbg = &priv->statistics.common.dbg;
1373 div = &priv->statistics.common.div;
1374 accum_general = &priv->accum_stats.common;
1375 accum_dbg = &priv->accum_stats.common.dbg;
1376 accum_div = &priv->accum_stats.common.div;
1377 delta_general = &priv->delta_stats.common;
1378 max_general = &priv->max_delta_stats.common;
1379 delta_dbg = &priv->delta_stats.common.dbg;
1380 max_dbg = &priv->max_delta_stats.common.dbg;
1381 delta_div = &priv->delta_stats.common.div;
1382 max_div = &priv->max_delta_stats.common.div;
1383
1384 pos += iwl_statistics_flag(priv, buf, bufsz);
1385 pos += scnprintf(buf + pos, bufsz - pos,
1386 fmt_header, "Statistics_General:");
1387 pos += scnprintf(buf + pos, bufsz - pos,
1388 fmt_value, "temperature:",
1389 le32_to_cpu(general->temperature));
1390 pos += scnprintf(buf + pos, bufsz - pos,
1391 fmt_value, "temperature_m:",
1392 le32_to_cpu(general->temperature_m));
1393 pos += scnprintf(buf + pos, bufsz - pos,
1394 fmt_value, "ttl_timestamp:",
1395 le32_to_cpu(general->ttl_timestamp));
1396 pos += scnprintf(buf + pos, bufsz - pos,
1397 fmt_table, "burst_check:",
1398 le32_to_cpu(dbg->burst_check),
1399 accum_dbg->burst_check,
1400 delta_dbg->burst_check, max_dbg->burst_check);
1401 pos += scnprintf(buf + pos, bufsz - pos,
1402 fmt_table, "burst_count:",
1403 le32_to_cpu(dbg->burst_count),
1404 accum_dbg->burst_count,
1405 delta_dbg->burst_count, max_dbg->burst_count);
1406 pos += scnprintf(buf + pos, bufsz - pos,
1407 fmt_table, "wait_for_silence_timeout_count:",
1408 le32_to_cpu(dbg->wait_for_silence_timeout_cnt),
1409 accum_dbg->wait_for_silence_timeout_cnt,
1410 delta_dbg->wait_for_silence_timeout_cnt,
1411 max_dbg->wait_for_silence_timeout_cnt);
1412 pos += scnprintf(buf + pos, bufsz - pos,
1413 fmt_table, "sleep_time:",
1414 le32_to_cpu(general->sleep_time),
1415 accum_general->sleep_time,
1416 delta_general->sleep_time, max_general->sleep_time);
1417 pos += scnprintf(buf + pos, bufsz - pos,
1418 fmt_table, "slots_out:",
1419 le32_to_cpu(general->slots_out),
1420 accum_general->slots_out,
1421 delta_general->slots_out, max_general->slots_out);
1422 pos += scnprintf(buf + pos, bufsz - pos,
1423 fmt_table, "slots_idle:",
1424 le32_to_cpu(general->slots_idle),
1425 accum_general->slots_idle,
1426 delta_general->slots_idle, max_general->slots_idle);
1427 pos += scnprintf(buf + pos, bufsz - pos,
1428 fmt_table, "tx_on_a:",
1429 le32_to_cpu(div->tx_on_a), accum_div->tx_on_a,
1430 delta_div->tx_on_a, max_div->tx_on_a);
1431 pos += scnprintf(buf + pos, bufsz - pos,
1432 fmt_table, "tx_on_b:",
1433 le32_to_cpu(div->tx_on_b), accum_div->tx_on_b,
1434 delta_div->tx_on_b, max_div->tx_on_b);
1435 pos += scnprintf(buf + pos, bufsz - pos,
1436 fmt_table, "exec_time:",
1437 le32_to_cpu(div->exec_time), accum_div->exec_time,
1438 delta_div->exec_time, max_div->exec_time);
1439 pos += scnprintf(buf + pos, bufsz - pos,
1440 fmt_table, "probe_time:",
1441 le32_to_cpu(div->probe_time), accum_div->probe_time,
1442 delta_div->probe_time, max_div->probe_time);
1443 pos += scnprintf(buf + pos, bufsz - pos,
1444 fmt_table, "rx_enable_counter:",
1445 le32_to_cpu(general->rx_enable_counter),
1446 accum_general->rx_enable_counter,
1447 delta_general->rx_enable_counter,
1448 max_general->rx_enable_counter);
1449 pos += scnprintf(buf + pos, bufsz - pos,
1450 fmt_table, "num_of_sos_states:",
1451 le32_to_cpu(general->num_of_sos_states),
1452 accum_general->num_of_sos_states,
1453 delta_general->num_of_sos_states,
1454 max_general->num_of_sos_states);
4ff70fcd
JB		 1455
1456 spin_unlock_bh(&priv->statistics.lock);
1457
d6d023a1
WYG		 1458 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1459 kfree(buf);
1460 return ret;
1461}
1462
1463static ssize_t iwl_dbgfs_ucode_bt_stats_read(struct file *file,
1464 char __user *user_buf,
1465 size_t count, loff_t *ppos)
1466{
1467 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
1468 int pos = 0;
1469 char *buf;
1470 int bufsz = (sizeof(struct statistics_bt_activity) * 24) + 200;
1471 ssize_t ret;
1472 struct statistics_bt_activity *bt, *accum_bt;
1473
83626404 1474 if (!iwl_is_alive(priv))
d6d023a1
WYG		 1475 return -EAGAIN;
1476
1477 if (!priv->bt_enable_flag)
1478 return -EINVAL;
1479
1480 /* make request to uCode to retrieve statistics information */
b1eea297 1481 mutex_lock(&priv->mutex);
a1022927 1482 ret = iwl_send_statistics_request(priv, 0, false);
b1eea297 1483 mutex_unlock(&priv->mutex);
d6d023a1 1484
f9e75447 1485 if (ret)
d6d023a1 1486 return -EAGAIN;
d6d023a1 1487 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 1488 if (!buf)
d6d023a1 1489 return -ENOMEM;
d6d023a1
WYG		 1490
1491 /*
1492 * the statistic information display here is based on
1493 * the last statistics notification from uCode
1494 * might not reflect the current uCode activity
1495 */
4ff70fcd
JB		 1496
1497 spin_lock_bh(&priv->statistics.lock);
1498
d6d023a1
WYG		 1499 bt = &priv->statistics.bt_activity;
1500 accum_bt = &priv->accum_stats.bt_activity;
1501
1502 pos += iwl_statistics_flag(priv, buf, bufsz);
1503 pos += scnprintf(buf + pos, bufsz - pos, "Statistics_BT:\n");
1504 pos += scnprintf(buf + pos, bufsz - pos,
1505 "\t\t\tcurrent\t\t\taccumulative\n");
1506 pos += scnprintf(buf + pos, bufsz - pos,
1507 "hi_priority_tx_req_cnt:\t\t%u\t\t\t%u\n",
1508 le32_to_cpu(bt->hi_priority_tx_req_cnt),
1509 accum_bt->hi_priority_tx_req_cnt);
1510 pos += scnprintf(buf + pos, bufsz - pos,
1511 "hi_priority_tx_denied_cnt:\t%u\t\t\t%u\n",
1512 le32_to_cpu(bt->hi_priority_tx_denied_cnt),
1513 accum_bt->hi_priority_tx_denied_cnt);
1514 pos += scnprintf(buf + pos, bufsz - pos,
1515 "lo_priority_tx_req_cnt:\t\t%u\t\t\t%u\n",
1516 le32_to_cpu(bt->lo_priority_tx_req_cnt),
1517 accum_bt->lo_priority_tx_req_cnt);
1518 pos += scnprintf(buf + pos, bufsz - pos,
1519 "lo_priority_tx_denied_cnt:\t%u\t\t\t%u\n",
1520 le32_to_cpu(bt->lo_priority_tx_denied_cnt),
1521 accum_bt->lo_priority_tx_denied_cnt);
1522 pos += scnprintf(buf + pos, bufsz - pos,
1523 "hi_priority_rx_req_cnt:\t\t%u\t\t\t%u\n",
1524 le32_to_cpu(bt->hi_priority_rx_req_cnt),
1525 accum_bt->hi_priority_rx_req_cnt);
1526 pos += scnprintf(buf + pos, bufsz - pos,
1527 "hi_priority_rx_denied_cnt:\t%u\t\t\t%u\n",
1528 le32_to_cpu(bt->hi_priority_rx_denied_cnt),
1529 accum_bt->hi_priority_rx_denied_cnt);
1530 pos += scnprintf(buf + pos, bufsz - pos,
1531 "lo_priority_rx_req_cnt:\t\t%u\t\t\t%u\n",
1532 le32_to_cpu(bt->lo_priority_rx_req_cnt),
1533 accum_bt->lo_priority_rx_req_cnt);
1534 pos += scnprintf(buf + pos, bufsz - pos,
1535 "lo_priority_rx_denied_cnt:\t%u\t\t\t%u\n",
1536 le32_to_cpu(bt->lo_priority_rx_denied_cnt),
1537 accum_bt->lo_priority_rx_denied_cnt);
1538
1539 pos += scnprintf(buf + pos, bufsz - pos,
1540 "(rx)num_bt_kills:\t\t%u\t\t\t%u\n",
1541 le32_to_cpu(priv->statistics.num_bt_kills),
1542 priv->statistics.accum_num_bt_kills);
1543
4ff70fcd
JB		 1544 spin_unlock_bh(&priv->statistics.lock);
1545
d6d023a1
WYG		 1546 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1547 kfree(buf);
1548 return ret;
1549}
1550
1551static ssize_t iwl_dbgfs_reply_tx_error_read(struct file *file,
1552 char __user *user_buf,
1553 size_t count, loff_t *ppos)
1554{
1555 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
1556 int pos = 0;
1557 char *buf;
1558 int bufsz = (sizeof(struct reply_tx_error_statistics) * 24) +
1559 (sizeof(struct reply_agg_tx_error_statistics) * 24) + 200;
1560 ssize_t ret;
1561
83626404 1562 if (!iwl_is_alive(priv))
d6d023a1
WYG		 1563 return -EAGAIN;
1564
1565 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 1566 if (!buf)
d6d023a1 1567 return -ENOMEM;
d6d023a1
WYG		 1568
1569 pos += scnprintf(buf + pos, bufsz - pos, "Statistics_TX_Error:\n");
1570 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t\t%u\n",
1571 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_DELAY),
898ed67b 1572 priv->reply_tx_stats.pp_delay);
d6d023a1
WYG		 1573 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1574 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_FEW_BYTES),
898ed67b 1575 priv->reply_tx_stats.pp_few_bytes);
d6d023a1
WYG		 1576 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1577 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_BT_PRIO),
898ed67b 1578 priv->reply_tx_stats.pp_bt_prio);
d6d023a1
WYG		 1579 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1580 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_QUIET_PERIOD),
898ed67b 1581 priv->reply_tx_stats.pp_quiet_period);
d6d023a1
WYG		 1582 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1583 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_CALC_TTAK),
898ed67b 1584 priv->reply_tx_stats.pp_calc_ttak);
d6d023a1
WYG		 1585 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1586 iwl_get_tx_fail_reason(
1587 TX_STATUS_FAIL_INTERNAL_CROSSED_RETRY),
898ed67b 1588 priv->reply_tx_stats.int_crossed_retry);
d6d023a1
WYG		 1589 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1590 iwl_get_tx_fail_reason(TX_STATUS_FAIL_SHORT_LIMIT),
898ed67b 1591 priv->reply_tx_stats.short_limit);
d6d023a1
WYG		 1592 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1593 iwl_get_tx_fail_reason(TX_STATUS_FAIL_LONG_LIMIT),
898ed67b 1594 priv->reply_tx_stats.long_limit);
d6d023a1
WYG		 1595 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1596 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FIFO_UNDERRUN),
898ed67b 1597 priv->reply_tx_stats.fifo_underrun);
d6d023a1
WYG		 1598 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1599 iwl_get_tx_fail_reason(TX_STATUS_FAIL_DRAIN_FLOW),
898ed67b 1600 priv->reply_tx_stats.drain_flow);
d6d023a1
WYG		 1601 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1602 iwl_get_tx_fail_reason(TX_STATUS_FAIL_RFKILL_FLUSH),
898ed67b 1603 priv->reply_tx_stats.rfkill_flush);
d6d023a1
WYG		 1604 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1605 iwl_get_tx_fail_reason(TX_STATUS_FAIL_LIFE_EXPIRE),
898ed67b 1606 priv->reply_tx_stats.life_expire);
d6d023a1
WYG		 1607 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1608 iwl_get_tx_fail_reason(TX_STATUS_FAIL_DEST_PS),
898ed67b 1609 priv->reply_tx_stats.dest_ps);
d6d023a1
WYG		 1610 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1611 iwl_get_tx_fail_reason(TX_STATUS_FAIL_HOST_ABORTED),
898ed67b 1612 priv->reply_tx_stats.host_abort);
d6d023a1
WYG		 1613 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1614 iwl_get_tx_fail_reason(TX_STATUS_FAIL_BT_RETRY),
898ed67b 1615 priv->reply_tx_stats.pp_delay);
d6d023a1
WYG		 1616 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1617 iwl_get_tx_fail_reason(TX_STATUS_FAIL_STA_INVALID),
898ed67b 1618 priv->reply_tx_stats.sta_invalid);
d6d023a1
WYG		 1619 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1620 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FRAG_DROPPED),
898ed67b 1621 priv->reply_tx_stats.frag_drop);
d6d023a1
WYG		 1622 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1623 iwl_get_tx_fail_reason(TX_STATUS_FAIL_TID_DISABLE),
898ed67b 1624 priv->reply_tx_stats.tid_disable);
d6d023a1
WYG		 1625 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1626 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FIFO_FLUSHED),
898ed67b 1627 priv->reply_tx_stats.fifo_flush);
d6d023a1
WYG		 1628 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1629 iwl_get_tx_fail_reason(
1630 TX_STATUS_FAIL_INSUFFICIENT_CF_POLL),
898ed67b 1631 priv->reply_tx_stats.insuff_cf_poll);
d6d023a1
WYG		 1632 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1633 iwl_get_tx_fail_reason(TX_STATUS_FAIL_PASSIVE_NO_RX),
898ed67b 1634 priv->reply_tx_stats.fail_hw_drop);
d6d023a1
WYG		 1635 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1636 iwl_get_tx_fail_reason(
1637 TX_STATUS_FAIL_NO_BEACON_ON_RADAR),
898ed67b 1638 priv->reply_tx_stats.sta_color_mismatch);
d6d023a1 1639 pos += scnprintf(buf + pos, bufsz - pos, "UNKNOWN:\t\t\t%u\n",
898ed67b 1640 priv->reply_tx_stats.unknown);
d6d023a1
WYG		 1641
1642 pos += scnprintf(buf + pos, bufsz - pos,
1643 "\nStatistics_Agg_TX_Error:\n");
1644
1645 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1646 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_UNDERRUN_MSK),
898ed67b 1647 priv->reply_agg_tx_stats.underrun);
d6d023a1
WYG		 1648 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1649 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_BT_PRIO_MSK),
898ed67b 1650 priv->reply_agg_tx_stats.bt_prio);
d6d023a1
WYG		 1651 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1652 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_FEW_BYTES_MSK),
898ed67b 1653 priv->reply_agg_tx_stats.few_bytes);
d6d023a1
WYG		 1654 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1655 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_ABORT_MSK),
898ed67b 1656 priv->reply_agg_tx_stats.abort);
d6d023a1
WYG		 1657 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1658 iwl_get_agg_tx_fail_reason(
1659 AGG_TX_STATE_LAST_SENT_TTL_MSK),
898ed67b 1660 priv->reply_agg_tx_stats.last_sent_ttl);
d6d023a1
WYG		 1661 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1662 iwl_get_agg_tx_fail_reason(
1663 AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK),
898ed67b 1664 priv->reply_agg_tx_stats.last_sent_try);
d6d023a1
WYG		 1665 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1666 iwl_get_agg_tx_fail_reason(
1667 AGG_TX_STATE_LAST_SENT_BT_KILL_MSK),
898ed67b 1668 priv->reply_agg_tx_stats.last_sent_bt_kill);
d6d023a1
WYG		 1669 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1670 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_SCD_QUERY_MSK),
898ed67b 1671 priv->reply_agg_tx_stats.scd_query);
d6d023a1
WYG		 1672 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t%u\n",
1673 iwl_get_agg_tx_fail_reason(
1674 AGG_TX_STATE_TEST_BAD_CRC32_MSK),
898ed67b 1675 priv->reply_agg_tx_stats.bad_crc32);
d6d023a1
WYG		 1676 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1677 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_RESPONSE_MSK),
898ed67b 1678 priv->reply_agg_tx_stats.response);
d6d023a1
WYG		 1679 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1680 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_DUMP_TX_MSK),
898ed67b 1681 priv->reply_agg_tx_stats.dump_tx);
d6d023a1
WYG		 1682 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1683 iwl_get_agg_tx_fail_reason(AGG_TX_STATE_DELAY_TX_MSK),
898ed67b 1684 priv->reply_agg_tx_stats.delay_tx);
d6d023a1 1685 pos += scnprintf(buf + pos, bufsz - pos, "UNKNOWN:\t\t\t%u\n",
898ed67b 1686 priv->reply_agg_tx_stats.unknown);
d6d023a1
WYG		 1687
1688 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1689 kfree(buf);
1690 return ret;
e8fe59ae
WYG		 1691}
1692
5225935b
WYG		 1693static ssize_t iwl_dbgfs_sensitivity_read(struct file *file,
1694 char __user *user_buf,
1695 size_t count, loff_t *ppos) {
1696
28f63a4b 1697 struct iwl_priv *priv = file->private_data;
5225935b
WYG		 1698 int pos = 0;
1699 int cnt = 0;
1700 char *buf;
1701 int bufsz = sizeof(struct iwl_sensitivity_data) * 4 + 100;
1702 ssize_t ret;
1703 struct iwl_sensitivity_data *data;
1704
1705 data = &priv->sensitivity_data;
1706 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 1707 if (!buf)
5225935b 1708 return -ENOMEM;
5225935b
WYG		 1709
1710 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm:\t\t\t %u\n",
1711 data->auto_corr_ofdm);
1712 pos += scnprintf(buf + pos, bufsz - pos,
1713 "auto_corr_ofdm_mrc:\t\t %u\n",
1714 data->auto_corr_ofdm_mrc);
1715 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_x1:\t\t %u\n",
1716 data->auto_corr_ofdm_x1);
1717 pos += scnprintf(buf + pos, bufsz - pos,
1718 "auto_corr_ofdm_mrc_x1:\t\t %u\n",
1719 data->auto_corr_ofdm_mrc_x1);
1720 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_cck:\t\t\t %u\n",
1721 data->auto_corr_cck);
1722 pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_cck_mrc:\t\t %u\n",
1723 data->auto_corr_cck_mrc);
1724 pos += scnprintf(buf + pos, bufsz - pos,
1725 "last_bad_plcp_cnt_ofdm:\t\t %u\n",
1726 data->last_bad_plcp_cnt_ofdm);
1727 pos += scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_ofdm:\t\t %u\n",
1728 data->last_fa_cnt_ofdm);
1729 pos += scnprintf(buf + pos, bufsz - pos,
1730 "last_bad_plcp_cnt_cck:\t\t %u\n",
1731 data->last_bad_plcp_cnt_cck);
1732 pos += scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_cck:\t\t %u\n",
1733 data->last_fa_cnt_cck);
1734 pos += scnprintf(buf + pos, bufsz - pos, "nrg_curr_state:\t\t\t %u\n",
1735 data->nrg_curr_state);
1736 pos += scnprintf(buf + pos, bufsz - pos, "nrg_prev_state:\t\t\t %u\n",
1737 data->nrg_prev_state);
1738 pos += scnprintf(buf + pos, bufsz - pos, "nrg_value:\t\t\t");
1739 for (cnt = 0; cnt < 10; cnt++) {
1740 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1741 data->nrg_value[cnt]);
1742 }
1743 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1744 pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_rssi:\t\t");
1745 for (cnt = 0; cnt < NRG_NUM_PREV_STAT_L; cnt++) {
1746 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1747 data->nrg_silence_rssi[cnt]);
1748 }
1749 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1750 pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_ref:\t\t %u\n",
1751 data->nrg_silence_ref);
1752 pos += scnprintf(buf + pos, bufsz - pos, "nrg_energy_idx:\t\t\t %u\n",
1753 data->nrg_energy_idx);
1754 pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_idx:\t\t %u\n",
1755 data->nrg_silence_idx);
1756 pos += scnprintf(buf + pos, bufsz - pos, "nrg_th_cck:\t\t\t %u\n",
1757 data->nrg_th_cck);
1758 pos += scnprintf(buf + pos, bufsz - pos,
1759 "nrg_auto_corr_silence_diff:\t %u\n",
1760 data->nrg_auto_corr_silence_diff);
1761 pos += scnprintf(buf + pos, bufsz - pos, "num_in_cck_no_fa:\t\t %u\n",
1762 data->num_in_cck_no_fa);
1763 pos += scnprintf(buf + pos, bufsz - pos, "nrg_th_ofdm:\t\t\t %u\n",
1764 data->nrg_th_ofdm);
1765
1766 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1767 kfree(buf);
1768 return ret;
1769}
1770
1771
1772static ssize_t iwl_dbgfs_chain_noise_read(struct file *file,
1773 char __user *user_buf,
1774 size_t count, loff_t *ppos) {
1775
28f63a4b 1776 struct iwl_priv *priv = file->private_data;
5225935b
WYG		 1777 int pos = 0;
1778 int cnt = 0;
1779 char *buf;
1780 int bufsz = sizeof(struct iwl_chain_noise_data) * 4 + 100;
1781 ssize_t ret;
1782 struct iwl_chain_noise_data *data;
1783
1784 data = &priv->chain_noise_data;
1785 buf = kzalloc(bufsz, GFP_KERNEL);
f9e75447 1786 if (!buf)
5225935b 1787 return -ENOMEM;
5225935b
WYG		 1788
1789 pos += scnprintf(buf + pos, bufsz - pos, "active_chains:\t\t\t %u\n",
1790 data->active_chains);
1791 pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_a:\t\t\t %u\n",
1792 data->chain_noise_a);
1793 pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_b:\t\t\t %u\n",
1794 data->chain_noise_b);
1795 pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_c:\t\t\t %u\n",
1796 data->chain_noise_c);
1797 pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_a:\t\t\t %u\n",
1798 data->chain_signal_a);
1799 pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_b:\t\t\t %u\n",
1800 data->chain_signal_b);
1801 pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_c:\t\t\t %u\n",
1802 data->chain_signal_c);
1803 pos += scnprintf(buf + pos, bufsz - pos, "beacon_count:\t\t\t %u\n",
1804 data->beacon_count);
1805
1806 pos += scnprintf(buf + pos, bufsz - pos, "disconn_array:\t\t\t");
1807 for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
1808 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1809 data->disconn_array[cnt]);
1810 }
1811 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1812 pos += scnprintf(buf + pos, bufsz - pos, "delta_gain_code:\t\t");
1813 for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
1814 pos += scnprintf(buf + pos, bufsz - pos, " %u",
1815 data->delta_gain_code[cnt]);
1816 }
1817 pos += scnprintf(buf + pos, bufsz - pos, "\n");
1818 pos += scnprintf(buf + pos, bufsz - pos, "radio_write:\t\t\t %u\n",
1819 data->radio_write);
1820 pos += scnprintf(buf + pos, bufsz - pos, "state:\t\t\t\t %u\n",
1821 data->state);
1822
1823 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1824 kfree(buf);
1825 return ret;
1826}
1827
c09430ab
WYG		 1828static ssize_t iwl_dbgfs_power_save_status_read(struct file *file,
1829 char __user *user_buf,
1830 size_t count, loff_t *ppos)
1831{
28f63a4b 1832 struct iwl_priv *priv = file->private_data;
c09430ab
WYG		 1833 char buf[60];
1834 int pos = 0;
1835 const size_t bufsz = sizeof(buf);
1836 u32 pwrsave_status;
1837
68e8dfda 1838 pwrsave_status = iwl_read32(priv->trans, CSR_GP_CNTRL) &
c09430ab
WYG		 1839 CSR_GP_REG_POWER_SAVE_STATUS_MSK;
1840
1841 pos += scnprintf(buf + pos, bufsz - pos, "Power Save Status: ");
1842 pos += scnprintf(buf + pos, bufsz - pos, "%s\n",
1843 (pwrsave_status == CSR_GP_REG_NO_POWER_SAVE) ? "none" :
1844 (pwrsave_status == CSR_GP_REG_MAC_POWER_SAVE) ? "MAC" :
1845 (pwrsave_status == CSR_GP_REG_PHY_POWER_SAVE) ? "PHY" :
1846 "error");
1847
1848 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1849}
1850
7163b8a4 1851static ssize_t iwl_dbgfs_clear_ucode_statistics_write(struct file *file,
ef8d5529
WYG		 1852 const char __user *user_buf,
1853 size_t count, loff_t *ppos)
1854{
1855 struct iwl_priv *priv = file->private_data;
1856 char buf[8];
1857 int buf_size;
1858 int clear;
1859
1860 memset(buf, 0, sizeof(buf));
1861 buf_size = min(count, sizeof(buf) - 1);
1862 if (copy_from_user(buf, user_buf, buf_size))
1863 return -EFAULT;
1864 if (sscanf(buf, "%d", &clear) != 1)
1865 return -EFAULT;
1866
1867 /* make request to uCode to retrieve statistics information */
b1eea297 1868 mutex_lock(&priv->mutex);
a1022927 1869 iwl_send_statistics_request(priv, 0, true);
b1eea297 1870 mutex_unlock(&priv->mutex);
ef8d5529
WYG		 1871
1872 return count;
1873}
1874
a9e1cb6a
WYG		 1875static ssize_t iwl_dbgfs_ucode_tracing_read(struct file *file,
1876 char __user *user_buf,
1877 size_t count, loff_t *ppos) {
1878
57674308 1879 struct iwl_priv *priv = file->private_data;
a9e1cb6a
WYG		 1880 int pos = 0;
1881 char buf[128];
1882 const size_t bufsz = sizeof(buf);
a9e1cb6a
WYG		 1883
1884 pos += scnprintf(buf + pos, bufsz - pos, "ucode trace timer is %s\n",
1885 priv->event_log.ucode_trace ? "On" : "Off");
1886 pos += scnprintf(buf + pos, bufsz - pos, "non_wraps_count:\t\t %u\n",
1887 priv->event_log.non_wraps_count);
1888 pos += scnprintf(buf + pos, bufsz - pos, "wraps_once_count:\t\t %u\n",
1889 priv->event_log.wraps_once_count);
1890 pos += scnprintf(buf + pos, bufsz - pos, "wraps_more_count:\t\t %u\n",
1891 priv->event_log.wraps_more_count);
1892
4967c316 1893 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
a9e1cb6a
WYG		 1894}
1895
1896static ssize_t iwl_dbgfs_ucode_tracing_write(struct file *file,
1897 const char __user *user_buf,
1898 size_t count, loff_t *ppos)
1899{
1900 struct iwl_priv *priv = file->private_data;
1901 char buf[8];
1902 int buf_size;
1903 int trace;
1904
1905 memset(buf, 0, sizeof(buf));
1906 buf_size = min(count, sizeof(buf) - 1);
1907 if (copy_from_user(buf, user_buf, buf_size))
1908 return -EFAULT;
1909 if (sscanf(buf, "%d", &trace) != 1)
1910 return -EFAULT;
1911
1912 if (trace) {
1913 priv->event_log.ucode_trace = true;
83626404 1914 if (iwl_is_alive(priv)) {
98d4bf0c
JB		 1915 /* start collecting data now */
1916 mod_timer(&priv->ucode_trace, jiffies);
1917 }
a9e1cb6a
WYG		 1918 } else {
1919 priv->event_log.ucode_trace = false;
1920 del_timer_sync(&priv->ucode_trace);
1921 }
1922
1923 return count;
1924}
1925
60987206
JB		 1926static ssize_t iwl_dbgfs_rxon_flags_read(struct file *file,
1927 char __user *user_buf,
1928 size_t count, loff_t *ppos) {
1929
57674308 1930 struct iwl_priv *priv = file->private_data;
60987206
JB		 1931 int len = 0;
1932 char buf[20];
1933
246ed355
JB		 1934 len = sprintf(buf, "0x%04X\n",
1935 le32_to_cpu(priv->contexts[IWL_RXON_CTX_BSS].active.flags));
60987206
JB		 1936 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1937}
1938
1939static ssize_t iwl_dbgfs_rxon_filter_flags_read(struct file *file,
1940 char __user *user_buf,
1941 size_t count, loff_t *ppos) {
1942
57674308 1943 struct iwl_priv *priv = file->private_data;
60987206
JB		 1944 int len = 0;
1945 char buf[20];
1946
1947 len = sprintf(buf, "0x%04X\n",
246ed355 1948 le32_to_cpu(priv->contexts[IWL_RXON_CTX_BSS].active.filter_flags));
60987206
JB		 1949 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1950}
1951
a13d276f
WYG		 1952static ssize_t iwl_dbgfs_missed_beacon_read(struct file *file,
1953 char __user *user_buf,
1954 size_t count, loff_t *ppos) {
1955
1956 struct iwl_priv *priv = file->private_data;
1957 int pos = 0;
1958 char buf[12];
1959 const size_t bufsz = sizeof(buf);
a13d276f
WYG		 1960
1961 pos += scnprintf(buf + pos, bufsz - pos, "%d\n",
1962 priv->missed_beacon_threshold);
1963
4967c316 1964 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
a13d276f
WYG		 1965}
1966
1967static ssize_t iwl_dbgfs_missed_beacon_write(struct file *file,
1968 const char __user *user_buf,
1969 size_t count, loff_t *ppos)
1970{
1971 struct iwl_priv *priv = file->private_data;
1972 char buf[8];
1973 int buf_size;
1974 int missed;
1975
1976 memset(buf, 0, sizeof(buf));
1977 buf_size = min(count, sizeof(buf) - 1);
1978 if (copy_from_user(buf, user_buf, buf_size))
1979 return -EFAULT;
1980 if (sscanf(buf, "%d", &missed) != 1)
1981 return -EINVAL;
1982
1983 if (missed < IWL_MISSED_BEACON_THRESHOLD_MIN ||
1984 missed > IWL_MISSED_BEACON_THRESHOLD_MAX)
1985 priv->missed_beacon_threshold =
1986 IWL_MISSED_BEACON_THRESHOLD_DEF;
1987 else
1988 priv->missed_beacon_threshold = missed;
1989
1990 return count;
1991}
1992
3e4fb5fa
TAN		 1993static ssize_t iwl_dbgfs_plcp_delta_read(struct file *file,
1994 char __user *user_buf,
1995 size_t count, loff_t *ppos) {
1996
57674308 1997 struct iwl_priv *priv = file->private_data;
3e4fb5fa
TAN		 1998 int pos = 0;
1999 char buf[12];
2000 const size_t bufsz = sizeof(buf);
3e4fb5fa
TAN		 2001
2002 pos += scnprintf(buf + pos, bufsz - pos, "%u\n",
ab5c0f1f 2003 priv->plcp_delta_threshold);
3e4fb5fa 2004
4967c316 2005 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
3e4fb5fa
TAN		 2006}
2007
2008static ssize_t iwl_dbgfs_plcp_delta_write(struct file *file,
2009 const char __user *user_buf,
2010 size_t count, loff_t *ppos) {
2011
2012 struct iwl_priv *priv = file->private_data;
2013 char buf[8];
2014 int buf_size;
2015 int plcp;
2016
2017 memset(buf, 0, sizeof(buf));
2018 buf_size = min(count, sizeof(buf) - 1);
2019 if (copy_from_user(buf, user_buf, buf_size))
2020 return -EFAULT;
2021 if (sscanf(buf, "%d", &plcp) != 1)
2022 return -EINVAL;
680788ac 2023 if ((plcp < IWL_MAX_PLCP_ERR_THRESHOLD_MIN) ||
3e4fb5fa 2024 (plcp > IWL_MAX_PLCP_ERR_THRESHOLD_MAX))
ab5c0f1f 2025 priv->plcp_delta_threshold =
680788ac 2026 IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE;
3e4fb5fa 2027 else
ab5c0f1f 2028 priv->plcp_delta_threshold = plcp;
3e4fb5fa
TAN		 2029 return count;
2030}
2031
48dffd39
JB		 2032static ssize_t iwl_dbgfs_rf_reset_read(struct file *file,
2033 char __user *user_buf,
2034 size_t count, loff_t *ppos)
ca934b67 2035{
528c3126 2036 struct iwl_priv *priv = file->private_data;
48dffd39 2037 int pos = 0;
528c3126
WYG		 2038 char buf[300];
2039 const size_t bufsz = sizeof(buf);
48dffd39
JB		 2040 struct iwl_rf_reset *rf_reset = &priv->rf_reset;
2041
2042 pos += scnprintf(buf + pos, bufsz - pos,
2043 "RF reset statistics\n");
2044 pos += scnprintf(buf + pos, bufsz - pos,
2045 "\tnumber of reset request: %d\n",
2046 rf_reset->reset_request_count);
2047 pos += scnprintf(buf + pos, bufsz - pos,
2048 "\tnumber of reset request success: %d\n",
2049 rf_reset->reset_success_count);
2050 pos += scnprintf(buf + pos, bufsz - pos,
2051 "\tnumber of reset request reject: %d\n",
2052 rf_reset->reset_reject_count);
528c3126 2053
528c3126
WYG		 2054 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2055}
2056
48dffd39 2057static ssize_t iwl_dbgfs_rf_reset_write(struct file *file,
04cafd7f
WYG		 2058 const char __user *user_buf,
2059 size_t count, loff_t *ppos) {
2060
2061 struct iwl_priv *priv = file->private_data;
48dffd39 2062 int ret;
04cafd7f 2063
48dffd39 2064 ret = iwl_force_rf_reset(priv, true);
04cafd7f
WYG		 2065 return ret ? ret : count;
2066}
2067
4bf49a90
WYG		 2068static ssize_t iwl_dbgfs_txfifo_flush_write(struct file *file,
2069 const char __user *user_buf,
2070 size_t count, loff_t *ppos) {
2071
2072 struct iwl_priv *priv = file->private_data;
2073 char buf[8];
2074 int buf_size;
2075 int flush;
2076
2077 memset(buf, 0, sizeof(buf));
2078 buf_size = min(count, sizeof(buf) - 1);
2079 if (copy_from_user(buf, user_buf, buf_size))
2080 return -EFAULT;
2081 if (sscanf(buf, "%d", &flush) != 1)
2082 return -EINVAL;
2083
83626404 2084 if (iwl_is_rfkill(priv))
4bf49a90
WYG		 2085 return -EFAULT;
2086
a4dece9a 2087 iwlagn_dev_txfifo_flush(priv);
4bf49a90
WYG		 2088
2089 return count;
2090}
2091
befe8c46
WYG		 2092static ssize_t iwl_dbgfs_bt_traffic_read(struct file *file,
2093 char __user *user_buf,
2094 size_t count, loff_t *ppos) {
2095
2096 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
2097 int pos = 0;
2098 char buf[200];
2099 const size_t bufsz = sizeof(buf);
befe8c46 2100
f21dd005
WYG		 2101 if (!priv->bt_enable_flag) {
2102 pos += scnprintf(buf + pos, bufsz - pos, "BT coex disabled\n");
08960dea 2103 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
f21dd005
WYG		 2104 }
2105 pos += scnprintf(buf + pos, bufsz - pos, "BT enable flag: 0x%x\n",
2106 priv->bt_enable_flag);
befe8c46
WYG		 2107 pos += scnprintf(buf + pos, bufsz - pos, "BT in %s mode\n",
2108 priv->bt_full_concurrent ? "full concurrency" : "3-wire");
2109 pos += scnprintf(buf + pos, bufsz - pos, "BT status: %s, "
2110 "last traffic notif: %d\n",
66e863a5 2111 priv->bt_status ? "On" : "Off", priv->last_bt_traffic_load);
befe8c46 2112 pos += scnprintf(buf + pos, bufsz - pos, "ch_announcement: %d, "
187bc4f6
WYG		 2113 "kill_ack_mask: %x, kill_cts_mask: %x\n",
2114 priv->bt_ch_announce, priv->kill_ack_mask,
2115 priv->kill_cts_mask);
befe8c46
WYG		 2116
2117 pos += scnprintf(buf + pos, bufsz - pos, "bluetooth traffic load: ");
2118 switch (priv->bt_traffic_load) {
2119 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS:
2120 pos += scnprintf(buf + pos, bufsz - pos, "Continuous\n");
2121 break;
2122 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH:
2123 pos += scnprintf(buf + pos, bufsz - pos, "High\n");
2124 break;
2125 case IWL_BT_COEX_TRAFFIC_LOAD_LOW:
2126 pos += scnprintf(buf + pos, bufsz - pos, "Low\n");
2127 break;
2128 case IWL_BT_COEX_TRAFFIC_LOAD_NONE:
2129 default:
2130 pos += scnprintf(buf + pos, bufsz - pos, "None\n");
2131 break;
2132 }
2133
08960dea 2134 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
befe8c46
WYG		 2135}
2136
c6abdc0d
WYG		 2137static ssize_t iwl_dbgfs_protection_mode_read(struct file *file,
2138 char __user *user_buf,
2139 size_t count, loff_t *ppos)
2140{
2141 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
2142
2143 int pos = 0;
2144 char buf[40];
2145 const size_t bufsz = sizeof(buf);
2146
2152268f 2147 if (priv->cfg->ht_params)
7cb1b088
WYG		 2148 pos += scnprintf(buf + pos, bufsz - pos,
2149 "use %s for aggregation\n",
9e295116 2150 (priv->hw_params.use_rts_for_aggregation) ?
7cb1b088
WYG		 2151 "rts/cts" : "cts-to-self");
2152 else
2153 pos += scnprintf(buf + pos, bufsz - pos, "N/A");
2154
c6abdc0d
WYG		 2155 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2156}
2157
2158static ssize_t iwl_dbgfs_protection_mode_write(struct file *file,
2159 const char __user *user_buf,
2160 size_t count, loff_t *ppos) {
2161
2162 struct iwl_priv *priv = file->private_data;
2163 char buf[8];
2164 int buf_size;
2165 int rts;
2166
2152268f 2167 if (!priv->cfg->ht_params)
7cb1b088
WYG		 2168 return -EINVAL;
2169
c6abdc0d
WYG		 2170 memset(buf, 0, sizeof(buf));
2171 buf_size = min(count, sizeof(buf) - 1);
2172 if (copy_from_user(buf, user_buf, buf_size))
2173 return -EFAULT;
2174 if (sscanf(buf, "%d", &rts) != 1)
2175 return -EINVAL;
2176 if (rts)
9e295116 2177 priv->hw_params.use_rts_for_aggregation = true;
c6abdc0d 2178 else
9e295116 2179 priv->hw_params.use_rts_for_aggregation = false;
c6abdc0d
WYG		 2180 return count;
2181}
2182
c98c8d99
JB		 2183static int iwl_cmd_echo_test(struct iwl_priv *priv)
2184{
2185 int ret;
2186 struct iwl_host_cmd cmd = {
2187 .id = REPLY_ECHO,
2188 .len = { 0 },
c98c8d99
JB		 2189 };
2190
2191 ret = iwl_dvm_send_cmd(priv, &cmd);
2192 if (ret)
2193 IWL_ERR(priv, "echo testing fail: 0X%x\n", ret);
2194 else
2195 IWL_DEBUG_INFO(priv, "echo testing pass\n");
2196 return ret;
2197}
2198
7e4005cc
WYG		 2199static ssize_t iwl_dbgfs_echo_test_write(struct file *file,
2200 const char __user *user_buf,
2201 size_t count, loff_t *ppos)
2202{
2203 struct iwl_priv *priv = file->private_data;
2204 char buf[8];
2205 int buf_size;
2206
2207 memset(buf, 0, sizeof(buf));
2208 buf_size = min(count, sizeof(buf) - 1);
2209 if (copy_from_user(buf, user_buf, buf_size))
2210 return -EFAULT;
2211
2212 iwl_cmd_echo_test(priv);
2213 return count;
2214}
2215
882b7b7d 2216#ifdef CONFIG_IWLWIFI_DEBUG
2fdfc476
MV		 2217static ssize_t iwl_dbgfs_log_event_read(struct file *file,
2218 char __user *user_buf,
2219 size_t count, loff_t *ppos)
2220{
2221 struct iwl_priv *priv = file->private_data;
3309ccf7
SG		 2222 char *buf = NULL;
2223 ssize_t ret;
2fdfc476 2224
a6db0061 2225 ret = iwl_dump_nic_event_log(priv, true, &buf);
d5578941
SG		 2226 if (ret > 0)
2227 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
3309ccf7 2228 kfree(buf);
2fdfc476
MV		 2229 return ret;
2230}
2231
2232static ssize_t iwl_dbgfs_log_event_write(struct file *file,
2233 const char __user *user_buf,
2234 size_t count, loff_t *ppos)
2235{
2236 struct iwl_priv *priv = file->private_data;
2237 u32 event_log_flag;
2238 char buf[8];
2239 int buf_size;
2240
0ff1bd35
RG		 2241 /* check that the interface is up */
2242 if (!iwl_is_ready(priv))
2243 return -EAGAIN;
2244
2fdfc476
MV		 2245 memset(buf, 0, sizeof(buf));
2246 buf_size = min(count, sizeof(buf) - 1);
2247 if (copy_from_user(buf, user_buf, buf_size))
2248 return -EFAULT;
2249 if (sscanf(buf, "%d", &event_log_flag) != 1)
2250 return -EFAULT;
2251 if (event_log_flag == 1)
a6db0061 2252 iwl_dump_nic_event_log(priv, true, NULL);
2fdfc476
MV		 2253
2254 return count;
2255}
882b7b7d 2256#endif
2fdfc476 2257
bfb45f54
DS		 2258static ssize_t iwl_dbgfs_calib_disabled_read(struct file *file,
2259 char __user *user_buf,
2260 size_t count, loff_t *ppos)
2261{
2262 struct iwl_priv *priv = file->private_data;
2263 char buf[120];
2264 int pos = 0;
2265 const size_t bufsz = sizeof(buf);
2266
2267 pos += scnprintf(buf + pos, bufsz - pos,
2268 "Sensitivity calibrations %s\n",
2269 (priv->calib_disabled &
2270 IWL_SENSITIVITY_CALIB_DISABLED) ?
2271 "DISABLED" : "ENABLED");
2272 pos += scnprintf(buf + pos, bufsz - pos,
2273 "Chain noise calibrations %s\n",
2274 (priv->calib_disabled &
2275 IWL_CHAIN_NOISE_CALIB_DISABLED) ?
2276 "DISABLED" : "ENABLED");
2277 pos += scnprintf(buf + pos, bufsz - pos,
2278 "Tx power calibrations %s\n",
2279 (priv->calib_disabled &
2280 IWL_TX_POWER_CALIB_DISABLED) ?
2281 "DISABLED" : "ENABLED");
2282
2283 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2284}
2285
647ad135
DS		 2286static ssize_t iwl_dbgfs_calib_disabled_write(struct file *file,
2287 const char __user *user_buf,
2288 size_t count, loff_t *ppos)
2289{
2290 struct iwl_priv *priv = file->private_data;
2291 char buf[8];
2292 u32 calib_disabled;
2293 int buf_size;
2294
2295 memset(buf, 0, sizeof(buf));
2296 buf_size = min(count, sizeof(buf) - 1);
2297 if (copy_from_user(buf, user_buf, buf_size))
2298 return -EFAULT;
2299 if (sscanf(buf, "%x", &calib_disabled) != 1)
2300 return -EFAULT;
2301
2302 priv->calib_disabled = calib_disabled;
2303
2304 return count;
2305}
2306
490953ac
EG		 2307static ssize_t iwl_dbgfs_fw_restart_write(struct file *file,
2308 const char __user *user_buf,
2309 size_t count, loff_t *ppos)
2310{
2311 struct iwl_priv *priv = file->private_data;
2312 bool restart_fw = iwlwifi_mod_params.restart_fw;
2313 int ret;
2314
2315 iwlwifi_mod_params.restart_fw = true;
2316
2317 mutex_lock(&priv->mutex);
2318
2319 /* take the return value to make compiler happy - it will fail anyway */
a1022927 2320 ret = iwl_dvm_send_cmd_pdu(priv, REPLY_ERROR, 0, 0, NULL);
490953ac
EG		 2321
2322 mutex_unlock(&priv->mutex);
2323
2324 iwlwifi_mod_params.restart_fw = restart_fw;
2325
2326 return count;
2327}
2328
e8fe59ae
WYG		 2329DEBUGFS_READ_FILE_OPS(ucode_rx_stats);
2330DEBUGFS_READ_FILE_OPS(ucode_tx_stats);
2331DEBUGFS_READ_FILE_OPS(ucode_general_stats);
5225935b
WYG		 2332DEBUGFS_READ_FILE_OPS(sensitivity);
2333DEBUGFS_READ_FILE_OPS(chain_noise);
c09430ab 2334DEBUGFS_READ_FILE_OPS(power_save_status);
7163b8a4 2335DEBUGFS_WRITE_FILE_OPS(clear_ucode_statistics);
a9e1cb6a 2336DEBUGFS_READ_WRITE_FILE_OPS(ucode_tracing);
a13d276f 2337DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon);
3e4fb5fa 2338DEBUGFS_READ_WRITE_FILE_OPS(plcp_delta);
48dffd39 2339DEBUGFS_READ_WRITE_FILE_OPS(rf_reset);
60987206
JB		 2340DEBUGFS_READ_FILE_OPS(rxon_flags);
2341DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
4bf49a90 2342DEBUGFS_WRITE_FILE_OPS(txfifo_flush);
ffb7d896 2343DEBUGFS_READ_FILE_OPS(ucode_bt_stats);
befe8c46 2344DEBUGFS_READ_FILE_OPS(bt_traffic);
c6abdc0d 2345DEBUGFS_READ_WRITE_FILE_OPS(protection_mode);
54a9aa65 2346DEBUGFS_READ_FILE_OPS(reply_tx_error);
7e4005cc 2347DEBUGFS_WRITE_FILE_OPS(echo_test);
490953ac 2348DEBUGFS_WRITE_FILE_OPS(fw_restart);
882b7b7d 2349#ifdef CONFIG_IWLWIFI_DEBUG
2fdfc476 2350DEBUGFS_READ_WRITE_FILE_OPS(log_event);
882b7b7d 2351#endif
647ad135 2352DEBUGFS_READ_WRITE_FILE_OPS(calib_disabled);
20594eb0 2353
712b6cf5
TW		 2354/*
2355 * Create the debugfs files and directories
2356 *
2357 */
9da987ac 2358int iwl_dbgfs_register(struct iwl_priv *priv, struct dentry *dbgfs_dir)
712b6cf5 2359{
9da987ac 2360 struct dentry *dir_data, *dir_rf, *dir_debug;
712b6cf5 2361
9da987ac 2362 priv->debugfs_dir = dbgfs_dir;
4c84a8f1 2363
9da987ac 2364 dir_data = debugfs_create_dir("data", dbgfs_dir);
4c84a8f1
JB		 2365 if (!dir_data)
2366 goto err;
9da987ac 2367 dir_rf = debugfs_create_dir("rf", dbgfs_dir);
4c84a8f1
JB		 2368 if (!dir_rf)
2369 goto err;
9da987ac 2370 dir_debug = debugfs_create_dir("debug", dbgfs_dir);
4c84a8f1 2371 if (!dir_debug)
712b6cf5 2372 goto err;
712b6cf5 2373
4c84a8f1
JB		 2374 DEBUGFS_ADD_FILE(nvm, dir_data, S_IRUSR);
2375 DEBUGFS_ADD_FILE(sram, dir_data, S_IWUSR | S_IRUSR);
c8ac61cf 2376 DEBUGFS_ADD_FILE(wowlan_sram, dir_data, S_IRUSR);
4c84a8f1
JB		 2377 DEBUGFS_ADD_FILE(stations, dir_data, S_IRUSR);
2378 DEBUGFS_ADD_FILE(channels, dir_data, S_IRUSR);
2379 DEBUGFS_ADD_FILE(status, dir_data, S_IRUSR);
1f7b6172 2380 DEBUGFS_ADD_FILE(rx_handlers, dir_data, S_IWUSR | S_IRUSR);
4c84a8f1 2381 DEBUGFS_ADD_FILE(qos, dir_data, S_IRUSR);
23c0fcc6
WYG		 2382 DEBUGFS_ADD_FILE(sleep_level_override, dir_data, S_IWUSR | S_IRUSR);
2383 DEBUGFS_ADD_FILE(current_sleep_command, dir_data, S_IRUSR);
4c84a8f1
JB		 2384 DEBUGFS_ADD_FILE(thermal_throttling, dir_data, S_IRUSR);
2385 DEBUGFS_ADD_FILE(disable_ht40, dir_data, S_IWUSR | S_IRUSR);
511afa3b 2386 DEBUGFS_ADD_FILE(temperature, dir_data, S_IRUSR);
ca934b67 2387
4c84a8f1
JB		 2388 DEBUGFS_ADD_FILE(power_save_status, dir_debug, S_IRUSR);
2389 DEBUGFS_ADD_FILE(clear_ucode_statistics, dir_debug, S_IWUSR);
4c84a8f1 2390 DEBUGFS_ADD_FILE(missed_beacon, dir_debug, S_IWUSR);
4c84a8f1 2391 DEBUGFS_ADD_FILE(plcp_delta, dir_debug, S_IWUSR | S_IRUSR);
48dffd39 2392 DEBUGFS_ADD_FILE(rf_reset, dir_debug, S_IWUSR | S_IRUSR);
b8c76267
AK		 2393 DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, S_IRUSR);
2394 DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, S_IRUSR);
2395 DEBUGFS_ADD_FILE(ucode_general_stats, dir_debug, S_IRUSR);
c68744fb 2396 DEBUGFS_ADD_FILE(txfifo_flush, dir_debug, S_IWUSR);
c6abdc0d 2397 DEBUGFS_ADD_FILE(protection_mode, dir_debug, S_IWUSR | S_IRUSR);
703bc583
WYG		 2398 DEBUGFS_ADD_FILE(sensitivity, dir_debug, S_IRUSR);
2399 DEBUGFS_ADD_FILE(chain_noise, dir_debug, S_IRUSR);
b7af6a99 2400 DEBUGFS_ADD_FILE(ucode_tracing, dir_debug, S_IWUSR | S_IRUSR);
0da0e5bf 2401 DEBUGFS_ADD_FILE(ucode_bt_stats, dir_debug, S_IRUSR);
54a9aa65 2402 DEBUGFS_ADD_FILE(reply_tx_error, dir_debug, S_IRUSR);
60987206
JB		 2403 DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR);
2404 DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR);
7e4005cc 2405 DEBUGFS_ADD_FILE(echo_test, dir_debug, S_IWUSR);
490953ac 2406 DEBUGFS_ADD_FILE(fw_restart, dir_debug, S_IWUSR);
882b7b7d 2407#ifdef CONFIG_IWLWIFI_DEBUG
2fdfc476 2408 DEBUGFS_ADD_FILE(log_event, dir_debug, S_IWUSR | S_IRUSR);
882b7b7d 2409#endif
2fdfc476 2410
88e58fc5 2411 if (iwl_advanced_bt_coexist(priv))
befe8c46 2412 DEBUGFS_ADD_FILE(bt_traffic, dir_debug, S_IRUSR);
ca934b67 2413
bfb45f54 2414 /* Calibrations disabled/enabled status*/
647ad135 2415 DEBUGFS_ADD_FILE(calib_disabled, dir_rf, S_IWUSR | S_IRUSR);
87e5666c 2416
9da987ac
MV		 2417 /*
2418 * Create a symlink with mac80211. This is not very robust, as it does
2419 * not remove the symlink created. The implicit assumption is that
2420 * when the opmode exits, mac80211 will also exit, and will remove
2421 * this symlink as part of its cleanup.
2422 */
2423 if (priv->mac80211_registered) {
2424 char buf[100];
27a22096 2425 struct dentry *mac80211_dir, *dev_dir;
9da987ac
MV		 2426
2427 dev_dir = dbgfs_dir->d_parent;
9da987ac
MV		 2428 mac80211_dir = priv->hw->wiphy->debugfsdir;
2429
27a22096 2430 snprintf(buf, 100, "../../%pd2", dev_dir);
9da987ac
MV		 2431
2432 if (!debugfs_create_symlink("iwlwifi", mac80211_dir, buf))
2433 goto err;
2434 }
2435
712b6cf5
TW		 2436 return 0;
2437
2438err:
9da987ac 2439 IWL_ERR(priv, "failed to create the dvm debugfs entries\n");
4c84a8f1 2440 return -ENOMEM;
712b6cf5 2441}
Linux kernel - Deliverables
This page took 1.040755 seconds and 5 git commands to generate.