?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net/mlx4_en: Move filters cleanup to a proper location
[linux/fpc-iii.git] / drivers / net / wireless / intel / iwlwifi / dvm / debugfs.c
blobf6591c83d636bcab4b49f415e0ddd1a9052326c9
1 /******************************************************************************
2 *
3 * GPL LICENSE SUMMARY
4 *
5 * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
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
22 * in the file called COPYING.
23 *
24 * Contact Information:
25 * Intel Linux Wireless <linuxwifi@intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *****************************************************************************/
28
29 #include <linux/slab.h>
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/debugfs.h>
33 #include <linux/ieee80211.h>
34 #include <net/mac80211.h>
35
36 #include "iwl-debug.h"
37 #include "iwl-trans.h"
38 #include "iwl-io.h"
39 #include "dev.h"
40 #include "agn.h"
41
42 /* create and remove of files */
43 #define DEBUGFS_ADD_FILE(name, parent, mode) do { \
44 if (!debugfs_create_file(#name, mode, parent, priv, \
45 &iwl_dbgfs_##name##_ops)) \
46 goto err; \
47 } while (0)
48
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; \
55 } while (0)
56
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; \
63 } while (0)
64
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
73 /* file operation */
74 #define DEBUGFS_READ_FILE_OPS(name) \
75 static const struct file_operations iwl_dbgfs_##name##_ops = { \
76 .read = iwl_dbgfs_##name##_read, \
77 .open = simple_open, \
78 .llseek = generic_file_llseek, \
79 };
80
81 #define DEBUGFS_WRITE_FILE_OPS(name) \
82 static const struct file_operations iwl_dbgfs_##name##_ops = { \
83 .write = iwl_dbgfs_##name##_write, \
84 .open = simple_open, \
85 .llseek = generic_file_llseek, \
86 };
87
88
89 #define DEBUGFS_READ_WRITE_FILE_OPS(name) \
90 static const struct file_operations iwl_dbgfs_##name##_ops = { \
91 .write = iwl_dbgfs_##name##_write, \
92 .read = iwl_dbgfs_##name##_read, \
93 .open = simple_open, \
94 .llseek = generic_file_llseek, \
95 };
96
97 static ssize_t iwl_dbgfs_sram_read(struct file *file,
98 char __user *user_buf,
99 size_t count, loff_t *ppos)
100 {
101 u32 val = 0;
102 char *buf;
103 ssize_t ret;
104 int i = 0;
105 bool device_format = false;
106 int offset = 0;
107 int len = 0;
108 int pos = 0;
109 int sram;
110 struct iwl_priv *priv = file->private_data;
111 const struct fw_img *img;
112 size_t bufsz;
113
114 if (!iwl_is_ready_rf(priv))
115 return -EAGAIN;
116
117 /* default is to dump the entire data segment */
118 if (!priv->dbgfs_sram_offset && !priv->dbgfs_sram_len) {
119 priv->dbgfs_sram_offset = 0x800000;
120 if (!priv->ucode_loaded)
121 return -EINVAL;
122 img = &priv->fw->img[priv->cur_ucode];
123 priv->dbgfs_sram_len = img->sec[IWL_UCODE_SECTION_DATA].len;
124 }
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;
133 buf = kmalloc(bufsz, GFP_KERNEL);
134 if (!buf)
135 return -ENOMEM;
136
137 pos += scnprintf(buf + pos, bufsz - pos, "sram_len: 0x%x\n",
138 len);
139 pos += scnprintf(buf + pos, bufsz - pos, "sram_offset: 0x%x\n",
140 priv->dbgfs_sram_offset);
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 */
147 val = iwl_trans_read_mem32(priv->trans, sram);
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;
166 val = iwl_trans_read_mem32(priv->trans, sram);
167 }
168
169 /* put in extra spaces and split lines for human readability */
170 if (++i == 16) {
171 i = 0;
172 pos += scnprintf(buf + pos, bufsz - pos, "\n");
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 }
178 }
179 if (i)
180 pos += scnprintf(buf + pos, bufsz - pos, "\n");
181
182 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
183 kfree(buf);
184 return ret;
185 }
186
187 static 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) {
202 priv->dbgfs_sram_offset = offset;
203 priv->dbgfs_sram_len = len;
204 } else if (sscanf(buf, "%x", &offset) == 1) {
205 priv->dbgfs_sram_offset = offset;
206 priv->dbgfs_sram_len = -4;
207 } else {
208 priv->dbgfs_sram_offset = 0;
209 priv->dbgfs_sram_len = 0;
210 }
211
212 return count;
213 }
214
215 static 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;
220 const struct fw_img *img = &priv->fw->img[IWL_UCODE_WOWLAN];
221
222 if (!priv->wowlan_sram)
223 return -ENODATA;
224
225 return simple_read_from_buffer(user_buf, count, ppos,
226 priv->wowlan_sram,
227 img->sec[IWL_UCODE_SECTION_DATA].len);
228 }
229 static ssize_t iwl_dbgfs_stations_read(struct file *file, char __user *user_buf,
230 size_t count, loff_t *ppos)
231 {
232 struct iwl_priv *priv = file->private_data;
233 struct iwl_station_entry *station;
234 struct iwl_tid_data *tid_data;
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);
240
241 buf = kmalloc(bufsz, GFP_KERNEL);
242 if (!buf)
243 return -ENOMEM;
244
245 pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
246 priv->num_stations);
247
248 for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
249 station = &priv->stations[i];
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,
257 "TID seqno next_rclmd "
258 "rate_n_flags state txq\n");
259
260 for (j = 0; j < IWL_MAX_TID_COUNT; j++) {
261 tid_data = &priv->tid_data[i][j];
262 pos += scnprintf(buf + pos, bufsz - pos,
263 "%d: 0x%.4x 0x%.4x 0x%.8x "
264 "%d %.2d",
265 j, tid_data->seq_number,
266 tid_data->next_reclaimed,
267 tid_data->agg.rate_n_flags,
268 tid_data->agg.state,
269 tid_data->agg.txq_id);
270
271 if (tid_data->agg.wait_for_ba)
272 pos += scnprintf(buf + pos, bufsz - pos,
273 " - waitforba");
274 pos += scnprintf(buf + pos, bufsz - pos, "\n");
275 }
276
277 pos += scnprintf(buf + pos, bufsz - pos, "\n");
278 }
279
280 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
281 kfree(buf);
282 return ret;
283 }
284
285 static ssize_t iwl_dbgfs_nvm_read(struct file *file,
286 char __user *user_buf,
287 size_t count,
288 loff_t *ppos)
289 {
290 ssize_t ret;
291 struct iwl_priv *priv = file->private_data;
292 int pos = 0, ofs = 0, buf_size = 0;
293 const u8 *ptr;
294 char *buf;
295 u16 nvm_ver;
296 size_t eeprom_len = priv->eeprom_blob_size;
297 buf_size = 4 * eeprom_len + 256;
298
299 if (eeprom_len % 16)
300 return -ENODATA;
301
302 ptr = priv->eeprom_blob;
303 if (!ptr)
304 return -ENOMEM;
305
306 /* 4 characters for byte 0xYY */
307 buf = kzalloc(buf_size, GFP_KERNEL);
308 if (!buf)
309 return -ENOMEM;
310
311 nvm_ver = priv->nvm_data->nvm_version;
312 pos += scnprintf(buf + pos, buf_size - pos,
313 "NVM version: 0x%x\n", nvm_ver);
314 for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
315 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x %16ph\n",
316 ofs, ptr + ofs);
317 }
318
319 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
320 kfree(buf);
321 return ret;
322 }
323
324 static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
325 size_t count, loff_t *ppos)
326 {
327 struct iwl_priv *priv = file->private_data;
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
334 buf = kzalloc(bufsz, GFP_KERNEL);
335 if (!buf)
336 return -ENOMEM;
337
338 supp_band = iwl_get_hw_mode(priv, NL80211_BAND_2GHZ);
339 if (supp_band) {
340 channels = supp_band->channels;
341
342 pos += scnprintf(buf + pos, bufsz - pos,
343 "Displaying %d channels in 2.4GHz band 802.11bg):\n",
344 supp_band->n_channels);
345
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",
349 channels[i].hw_value,
350 channels[i].max_power,
351 channels[i].flags & IEEE80211_CHAN_RADAR ?
352 " (IEEE 802.11h required)" : "",
353 ((channels[i].flags & IEEE80211_CHAN_NO_IR)
354 || (channels[i].flags &
355 IEEE80211_CHAN_RADAR)) ? "" :
356 ", IBSS",
357 channels[i].flags &
358 IEEE80211_CHAN_NO_IR ?
359 "passive only" : "active/passive");
360 }
361 supp_band = iwl_get_hw_mode(priv, NL80211_BAND_5GHZ);
362 if (supp_band) {
363 channels = supp_band->channels;
364
365 pos += scnprintf(buf + pos, bufsz - pos,
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",
372 channels[i].hw_value,
373 channels[i].max_power,
374 channels[i].flags & IEEE80211_CHAN_RADAR ?
375 " (IEEE 802.11h required)" : "",
376 ((channels[i].flags & IEEE80211_CHAN_NO_IR)
377 || (channels[i].flags &
378 IEEE80211_CHAN_RADAR)) ? "" :
379 ", IBSS",
380 channels[i].flags &
381 IEEE80211_CHAN_NO_IR ?
382 "passive only" : "active/passive");
383 }
384 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
385 kfree(buf);
386 return ret;
387 }
388
389 static ssize_t iwl_dbgfs_status_read(struct file *file,
390 char __user *user_buf,
391 size_t count, loff_t *ppos) {
392
393 struct iwl_priv *priv = file->private_data;
394 char buf[512];
395 int pos = 0;
396 const size_t bufsz = sizeof(buf);
397
398 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_RF_KILL_HW:\t %d\n",
399 test_bit(STATUS_RF_KILL_HW, &priv->status));
400 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_CT_KILL:\t\t %d\n",
401 test_bit(STATUS_CT_KILL, &priv->status));
402 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_ALIVE:\t\t %d\n",
403 test_bit(STATUS_ALIVE, &priv->status));
404 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_READY:\t\t %d\n",
405 test_bit(STATUS_READY, &priv->status));
406 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_EXIT_PENDING:\t %d\n",
407 test_bit(STATUS_EXIT_PENDING, &priv->status));
408 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_STATISTICS:\t %d\n",
409 test_bit(STATUS_STATISTICS, &priv->status));
410 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCANNING:\t %d\n",
411 test_bit(STATUS_SCANNING, &priv->status));
412 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_ABORTING:\t %d\n",
413 test_bit(STATUS_SCAN_ABORTING, &priv->status));
414 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_HW:\t\t %d\n",
415 test_bit(STATUS_SCAN_HW, &priv->status));
416 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_POWER_PMI:\t %d\n",
417 test_bit(STATUS_POWER_PMI, &priv->status));
418 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_FW_ERROR:\t %d\n",
419 test_bit(STATUS_FW_ERROR, &priv->status));
420 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
421 }
422
423 static ssize_t iwl_dbgfs_rx_handlers_read(struct file *file,
424 char __user *user_buf,
425 size_t count, loff_t *ppos) {
426
427 struct iwl_priv *priv = file->private_data;
428
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);
436 if (!buf)
437 return -ENOMEM;
438
439 for (cnt = 0; cnt < REPLY_MAX; cnt++) {
440 if (priv->rx_handlers_stats[cnt] > 0)
441 pos += scnprintf(buf + pos, bufsz - pos,
442 "\tRx handler[%36s]:\t\t %u\n",
443 iwl_get_cmd_string(priv->trans, (u32)cnt),
444 priv->rx_handlers_stats[cnt]);
445 }
446
447 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
448 kfree(buf);
449 return ret;
450 }
451
452 static ssize_t iwl_dbgfs_rx_handlers_write(struct file *file,
453 const char __user *user_buf,
454 size_t count, loff_t *ppos)
455 {
456 struct iwl_priv *priv = file->private_data;
457
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)
469 memset(&priv->rx_handlers_stats[0], 0,
470 sizeof(priv->rx_handlers_stats));
471
472 return count;
473 }
474
475 static ssize_t iwl_dbgfs_qos_read(struct file *file, char __user *user_buf,
476 size_t count, loff_t *ppos)
477 {
478 struct iwl_priv *priv = file->private_data;
479 struct iwl_rxon_context *ctx;
480 int pos = 0, i;
481 char buf[256 * NUM_IWL_RXON_CTX];
482 const size_t bufsz = sizeof(buf);
483
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,
491 "AC[%d]\t%u\t%u\t%u\t%u\n", i,
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");
498 }
499 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
500 }
501
502 static ssize_t iwl_dbgfs_thermal_throttling_read(struct file *file,
503 char __user *user_buf,
504 size_t count, loff_t *ppos)
505 {
506 struct iwl_priv *priv = file->private_data;
507 struct iwl_tt_mgmt *tt = &priv->thermal_throttle;
508 struct iwl_tt_restriction *restriction;
509 char buf[100];
510 int pos = 0;
511 const size_t bufsz = sizeof(buf);
512
513 pos += scnprintf(buf + pos, bufsz - pos,
514 "Thermal Throttling Mode: %s\n",
515 tt->advanced_tt ? "Advance" : "Legacy");
516 pos += scnprintf(buf + pos, bufsz - pos,
517 "Thermal Throttling State: %d\n",
518 tt->state);
519 if (tt->advanced_tt) {
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 }
531 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
532 }
533
534 static 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;
549 if (!iwl_is_any_associated(priv))
550 priv->disable_ht40 = ht40 ? true : false;
551 else
552 return -EINVAL;
553
554 return count;
555 }
556
557 static ssize_t iwl_dbgfs_disable_ht40_read(struct file *file,
558 char __user *user_buf,
559 size_t count, loff_t *ppos)
560 {
561 struct iwl_priv *priv = file->private_data;
562 char buf[100];
563 int pos = 0;
564 const size_t bufsz = sizeof(buf);
565
566 pos += scnprintf(buf + pos, bufsz - pos,
567 "11n 40MHz Mode: %s\n",
568 priv->disable_ht40 ? "Disabled" : "Enabled");
569 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
570 }
571
572 static 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
586 static 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 */
608 if (value == 0)
609 return -EINVAL;
610 else if (value > 0)
611 value -= 1;
612
613 if (value != -1 && (value < 0 || value >= IWL_POWER_NUM))
614 return -EINVAL;
615
616 if (!iwl_is_ready_rf(priv))
617 return -EAGAIN;
618
619 priv->power_data.debug_sleep_level_override = value;
620
621 mutex_lock(&priv->mutex);
622 iwl_power_update_mode(priv, true);
623 mutex_unlock(&priv->mutex);
624
625 return count;
626 }
627
628 static ssize_t iwl_dbgfs_sleep_level_override_read(struct file *file,
629 char __user *user_buf,
630 size_t count, loff_t *ppos)
631 {
632 struct iwl_priv *priv = file->private_data;
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
646 static ssize_t iwl_dbgfs_current_sleep_command_read(struct file *file,
647 char __user *user_buf,
648 size_t count, loff_t *ppos)
649 {
650 struct iwl_priv *priv = file->private_data;
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
670 DEBUGFS_READ_WRITE_FILE_OPS(sram);
671 DEBUGFS_READ_FILE_OPS(wowlan_sram);
672 DEBUGFS_READ_FILE_OPS(nvm);
673 DEBUGFS_READ_FILE_OPS(stations);
674 DEBUGFS_READ_FILE_OPS(channels);
675 DEBUGFS_READ_FILE_OPS(status);
676 DEBUGFS_READ_WRITE_FILE_OPS(rx_handlers);
677 DEBUGFS_READ_FILE_OPS(qos);
678 DEBUGFS_READ_FILE_OPS(thermal_throttling);
679 DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40);
680 DEBUGFS_READ_FILE_OPS(temperature);
681 DEBUGFS_READ_WRITE_FILE_OPS(sleep_level_override);
682 DEBUGFS_READ_FILE_OPS(current_sleep_command);
683
684 static const char *fmt_value = " %-30s %10u\n";
685 static const char *fmt_hex = " %-30s 0x%02X\n";
686 static const char *fmt_table = " %-30s %10u %10u %10u %10u\n";
687 static const char *fmt_header =
688 "%-32s current cumulative delta max\n";
689
690 static int iwl_statistics_flag(struct iwl_priv *priv, char *buf, int bufsz)
691 {
692 int p = 0;
693 u32 flag;
694
695 lockdep_assert_held(&priv->statistics.lock);
696
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
713 static ssize_t iwl_dbgfs_ucode_rx_stats_read(struct file *file,
714 char __user *user_buf,
715 size_t count, loff_t *ppos)
716 {
717 struct iwl_priv *priv = file->private_data;
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
730 if (!iwl_is_alive(priv))
731 return -EAGAIN;
732
733 buf = kzalloc(bufsz, GFP_KERNEL);
734 if (!buf)
735 return -ENOMEM;
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 */
742 spin_lock_bh(&priv->statistics.lock);
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
1139 spin_unlock_bh(&priv->statistics.lock);
1140
1141 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1142 kfree(buf);
1143 return ret;
1144 }
1145
1146 static ssize_t iwl_dbgfs_ucode_tx_stats_read(struct file *file,
1147 char __user *user_buf,
1148 size_t count, loff_t *ppos)
1149 {
1150 struct iwl_priv *priv = file->private_data;
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
1157 if (!iwl_is_alive(priv))
1158 return -EAGAIN;
1159
1160 buf = kzalloc(bufsz, GFP_KERNEL);
1161 if (!buf)
1162 return -ENOMEM;
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 */
1168 spin_lock_bh(&priv->statistics.lock);
1169
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");
1319 if ((priv->nvm_data->valid_tx_ant & ANT_A) &&
1320 tx->tx_power.ant_a)
1321 pos += scnprintf(buf + pos, bufsz - pos,
1322 fmt_hex, "antenna A:",
1323 tx->tx_power.ant_a);
1324 if ((priv->nvm_data->valid_tx_ant & ANT_B) &&
1325 tx->tx_power.ant_b)
1326 pos += scnprintf(buf + pos, bufsz - pos,
1327 fmt_hex, "antenna B:",
1328 tx->tx_power.ant_b);
1329 if ((priv->nvm_data->valid_tx_ant & ANT_C) &&
1330 tx->tx_power.ant_c)
1331 pos += scnprintf(buf + pos, bufsz - pos,
1332 fmt_hex, "antenna C:",
1333 tx->tx_power.ant_c);
1334 }
1335
1336 spin_unlock_bh(&priv->statistics.lock);
1337
1338 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1339 kfree(buf);
1340 return ret;
1341 }
1342
1343 static ssize_t iwl_dbgfs_ucode_general_stats_read(struct file *file,
1344 char __user *user_buf,
1345 size_t count, loff_t *ppos)
1346 {
1347 struct iwl_priv *priv = file->private_data;
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
1357 if (!iwl_is_alive(priv))
1358 return -EAGAIN;
1359
1360 buf = kzalloc(bufsz, GFP_KERNEL);
1361 if (!buf)
1362 return -ENOMEM;
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 */
1368
1369 spin_lock_bh(&priv->statistics.lock);
1370
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);
1455
1456 spin_unlock_bh(&priv->statistics.lock);
1457
1458 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1459 kfree(buf);
1460 return ret;
1461 }
1462
1463 static 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
1474 if (!iwl_is_alive(priv))
1475 return -EAGAIN;
1476
1477 if (!priv->bt_enable_flag)
1478 return -EINVAL;
1479
1480 /* make request to uCode to retrieve statistics information */
1481 mutex_lock(&priv->mutex);
1482 ret = iwl_send_statistics_request(priv, 0, false);
1483 mutex_unlock(&priv->mutex);
1484
1485 if (ret)
1486 return -EAGAIN;
1487 buf = kzalloc(bufsz, GFP_KERNEL);
1488 if (!buf)
1489 return -ENOMEM;
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 */
1496
1497 spin_lock_bh(&priv->statistics.lock);
1498
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
1544 spin_unlock_bh(&priv->statistics.lock);
1545
1546 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1547 kfree(buf);
1548 return ret;
1549 }
1550
1551 static 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
1562 if (!iwl_is_alive(priv))
1563 return -EAGAIN;
1564
1565 buf = kzalloc(bufsz, GFP_KERNEL);
1566 if (!buf)
1567 return -ENOMEM;
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),
1572 priv->reply_tx_stats.pp_delay);
1573 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1574 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_FEW_BYTES),
1575 priv->reply_tx_stats.pp_few_bytes);
1576 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1577 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_BT_PRIO),
1578 priv->reply_tx_stats.pp_bt_prio);
1579 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1580 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_QUIET_PERIOD),
1581 priv->reply_tx_stats.pp_quiet_period);
1582 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1583 iwl_get_tx_fail_reason(TX_STATUS_POSTPONE_CALC_TTAK),
1584 priv->reply_tx_stats.pp_calc_ttak);
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),
1588 priv->reply_tx_stats.int_crossed_retry);
1589 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1590 iwl_get_tx_fail_reason(TX_STATUS_FAIL_SHORT_LIMIT),
1591 priv->reply_tx_stats.short_limit);
1592 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1593 iwl_get_tx_fail_reason(TX_STATUS_FAIL_LONG_LIMIT),
1594 priv->reply_tx_stats.long_limit);
1595 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1596 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FIFO_UNDERRUN),
1597 priv->reply_tx_stats.fifo_underrun);
1598 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1599 iwl_get_tx_fail_reason(TX_STATUS_FAIL_DRAIN_FLOW),
1600 priv->reply_tx_stats.drain_flow);
1601 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1602 iwl_get_tx_fail_reason(TX_STATUS_FAIL_RFKILL_FLUSH),
1603 priv->reply_tx_stats.rfkill_flush);
1604 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1605 iwl_get_tx_fail_reason(TX_STATUS_FAIL_LIFE_EXPIRE),
1606 priv->reply_tx_stats.life_expire);
1607 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1608 iwl_get_tx_fail_reason(TX_STATUS_FAIL_DEST_PS),
1609 priv->reply_tx_stats.dest_ps);
1610 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1611 iwl_get_tx_fail_reason(TX_STATUS_FAIL_HOST_ABORTED),
1612 priv->reply_tx_stats.host_abort);
1613 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1614 iwl_get_tx_fail_reason(TX_STATUS_FAIL_BT_RETRY),
1615 priv->reply_tx_stats.pp_delay);
1616 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1617 iwl_get_tx_fail_reason(TX_STATUS_FAIL_STA_INVALID),
1618 priv->reply_tx_stats.sta_invalid);
1619 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1620 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FRAG_DROPPED),
1621 priv->reply_tx_stats.frag_drop);
1622 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1623 iwl_get_tx_fail_reason(TX_STATUS_FAIL_TID_DISABLE),
1624 priv->reply_tx_stats.tid_disable);
1625 pos += scnprintf(buf + pos, bufsz - pos, "%s:\t\t\t%u\n",
1626 iwl_get_tx_fail_reason(TX_STATUS_FAIL_FIFO_FLUSHED),
1627 priv->reply_tx_stats.fifo_flush);
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),
1631 priv->reply_tx_stats.insuff_cf_poll);
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),
1634 priv->reply_tx_stats.fail_hw_drop);
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),
1638 priv->reply_tx_stats.sta_color_mismatch);
1639 pos += scnprintf(buf + pos, bufsz - pos, "UNKNOWN:\t\t\t%u\n",
1640 priv->reply_tx_stats.unknown);
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),
1647 priv->reply_agg_tx_stats.underrun);
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),
1650 priv->reply_agg_tx_stats.bt_prio);
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),
1653 priv->reply_agg_tx_stats.few_bytes);
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),
1656 priv->reply_agg_tx_stats.abort);
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),
1660 priv->reply_agg_tx_stats.last_sent_ttl);
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),
1664 priv->reply_agg_tx_stats.last_sent_try);
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),
1668 priv->reply_agg_tx_stats.last_sent_bt_kill);
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),
1671 priv->reply_agg_tx_stats.scd_query);
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),
1675 priv->reply_agg_tx_stats.bad_crc32);
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),
1678 priv->reply_agg_tx_stats.response);
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),
1681 priv->reply_agg_tx_stats.dump_tx);
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),
1684 priv->reply_agg_tx_stats.delay_tx);
1685 pos += scnprintf(buf + pos, bufsz - pos, "UNKNOWN:\t\t\t%u\n",
1686 priv->reply_agg_tx_stats.unknown);
1687
1688 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1689 kfree(buf);
1690 return ret;
1691 }
1692
1693 static ssize_t iwl_dbgfs_sensitivity_read(struct file *file,
1694 char __user *user_buf,
1695 size_t count, loff_t *ppos) {
1696
1697 struct iwl_priv *priv = file->private_data;
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);
1707 if (!buf)
1708 return -ENOMEM;
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
1772 static ssize_t iwl_dbgfs_chain_noise_read(struct file *file,
1773 char __user *user_buf,
1774 size_t count, loff_t *ppos) {
1775
1776 struct iwl_priv *priv = file->private_data;
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);
1786 if (!buf)
1787 return -ENOMEM;
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
1828 static ssize_t iwl_dbgfs_power_save_status_read(struct file *file,
1829 char __user *user_buf,
1830 size_t count, loff_t *ppos)
1831 {
1832 struct iwl_priv *priv = file->private_data;
1833 char buf[60];
1834 int pos = 0;
1835 const size_t bufsz = sizeof(buf);
1836 u32 pwrsave_status;
1837
1838 pwrsave_status = iwl_read32(priv->trans, CSR_GP_CNTRL) &
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
1851 static ssize_t iwl_dbgfs_clear_ucode_statistics_write(struct file *file,
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 */
1868 mutex_lock(&priv->mutex);
1869 iwl_send_statistics_request(priv, 0, true);
1870 mutex_unlock(&priv->mutex);
1871
1872 return count;
1873 }
1874
1875 static ssize_t iwl_dbgfs_ucode_tracing_read(struct file *file,
1876 char __user *user_buf,
1877 size_t count, loff_t *ppos) {
1878
1879 struct iwl_priv *priv = file->private_data;
1880 int pos = 0;
1881 char buf[128];
1882 const size_t bufsz = sizeof(buf);
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
1893 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1894 }
1895
1896 static 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;
1914 if (iwl_is_alive(priv)) {
1915 /* start collecting data now */
1916 mod_timer(&priv->ucode_trace, jiffies);
1917 }
1918 } else {
1919 priv->event_log.ucode_trace = false;
1920 del_timer_sync(&priv->ucode_trace);
1921 }
1922
1923 return count;
1924 }
1925
1926 static ssize_t iwl_dbgfs_rxon_flags_read(struct file *file,
1927 char __user *user_buf,
1928 size_t count, loff_t *ppos) {
1929
1930 struct iwl_priv *priv = file->private_data;
1931 int len = 0;
1932 char buf[20];
1933
1934 len = sprintf(buf, "0x%04X\n",
1935 le32_to_cpu(priv->contexts[IWL_RXON_CTX_BSS].active.flags));
1936 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1937 }
1938
1939 static ssize_t iwl_dbgfs_rxon_filter_flags_read(struct file *file,
1940 char __user *user_buf,
1941 size_t count, loff_t *ppos) {
1942
1943 struct iwl_priv *priv = file->private_data;
1944 int len = 0;
1945 char buf[20];
1946
1947 len = sprintf(buf, "0x%04X\n",
1948 le32_to_cpu(priv->contexts[IWL_RXON_CTX_BSS].active.filter_flags));
1949 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1950 }
1951
1952 static 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);
1960
1961 pos += scnprintf(buf + pos, bufsz - pos, "%d\n",
1962 priv->missed_beacon_threshold);
1963
1964 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1965 }
1966
1967 static 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
1993 static ssize_t iwl_dbgfs_plcp_delta_read(struct file *file,
1994 char __user *user_buf,
1995 size_t count, loff_t *ppos) {
1996
1997 struct iwl_priv *priv = file->private_data;
1998 int pos = 0;
1999 char buf[12];
2000 const size_t bufsz = sizeof(buf);
2001
2002 pos += scnprintf(buf + pos, bufsz - pos, "%u\n",
2003 priv->plcp_delta_threshold);
2004
2005 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2006 }
2007
2008 static 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;
2023 if ((plcp < IWL_MAX_PLCP_ERR_THRESHOLD_MIN) ||
2024 (plcp > IWL_MAX_PLCP_ERR_THRESHOLD_MAX))
2025 priv->plcp_delta_threshold =
2026 IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE;
2027 else
2028 priv->plcp_delta_threshold = plcp;
2029 return count;
2030 }
2031
2032 static ssize_t iwl_dbgfs_rf_reset_read(struct file *file,
2033 char __user *user_buf,
2034 size_t count, loff_t *ppos)
2035 {
2036 struct iwl_priv *priv = file->private_data;
2037 int pos = 0;
2038 char buf[300];
2039 const size_t bufsz = sizeof(buf);
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);
2053
2054 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2055 }
2056
2057 static ssize_t iwl_dbgfs_rf_reset_write(struct file *file,
2058 const char __user *user_buf,
2059 size_t count, loff_t *ppos) {
2060
2061 struct iwl_priv *priv = file->private_data;
2062 int ret;
2063
2064 ret = iwl_force_rf_reset(priv, true);
2065 return ret ? ret : count;
2066 }
2067
2068 static 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
2084 if (iwl_is_rfkill(priv))
2085 return -EFAULT;
2086
2087 iwlagn_dev_txfifo_flush(priv);
2088
2089 return count;
2090 }
2091
2092 static 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);
2100
2101 if (!priv->bt_enable_flag) {
2102 pos += scnprintf(buf + pos, bufsz - pos, "BT coex disabled\n");
2103 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2104 }
2105 pos += scnprintf(buf + pos, bufsz - pos, "BT enable flag: 0x%x\n",
2106 priv->bt_enable_flag);
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",
2111 priv->bt_status ? "On" : "Off", priv->last_bt_traffic_load);
2112 pos += scnprintf(buf + pos, bufsz - pos, "ch_announcement: %d, "
2113 "kill_ack_mask: %x, kill_cts_mask: %x\n",
2114 priv->bt_ch_announce, priv->kill_ack_mask,
2115 priv->kill_cts_mask);
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
2134 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2135 }
2136
2137 static 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
2147 if (priv->cfg->ht_params)
2148 pos += scnprintf(buf + pos, bufsz - pos,
2149 "use %s for aggregation\n",
2150 (priv->hw_params.use_rts_for_aggregation) ?
2151 "rts/cts" : "cts-to-self");
2152 else
2153 pos += scnprintf(buf + pos, bufsz - pos, "N/A");
2154
2155 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
2156 }
2157
2158 static 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
2167 if (!priv->cfg->ht_params)
2168 return -EINVAL;
2169
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)
2177 priv->hw_params.use_rts_for_aggregation = true;
2178 else
2179 priv->hw_params.use_rts_for_aggregation = false;
2180 return count;
2181 }
2182
2183 static 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 },
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
2199 static 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
2216 #ifdef CONFIG_IWLWIFI_DEBUG
2217 static 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;
2222 char *buf = NULL;
2223 ssize_t ret;
2224
2225 ret = iwl_dump_nic_event_log(priv, true, &buf);
2226 if (ret > 0)
2227 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
2228 kfree(buf);
2229 return ret;
2230 }
2231
2232 static 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
2241 /* check that the interface is up */
2242 if (!iwl_is_ready(priv))
2243 return -EAGAIN;
2244
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)
2252 iwl_dump_nic_event_log(priv, true, NULL);
2253
2254 return count;
2255 }
2256 #endif
2257
2258 static 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
2286 static 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
2307 static 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 */
2320 ret = iwl_dvm_send_cmd_pdu(priv, REPLY_ERROR, 0, 0, NULL);
2321
2322 mutex_unlock(&priv->mutex);
2323
2324 iwlwifi_mod_params.restart_fw = restart_fw;
2325
2326 return count;
2327 }
2328
2329 DEBUGFS_READ_FILE_OPS(ucode_rx_stats);
2330 DEBUGFS_READ_FILE_OPS(ucode_tx_stats);
2331 DEBUGFS_READ_FILE_OPS(ucode_general_stats);
2332 DEBUGFS_READ_FILE_OPS(sensitivity);
2333 DEBUGFS_READ_FILE_OPS(chain_noise);
2334 DEBUGFS_READ_FILE_OPS(power_save_status);
2335 DEBUGFS_WRITE_FILE_OPS(clear_ucode_statistics);
2336 DEBUGFS_READ_WRITE_FILE_OPS(ucode_tracing);
2337 DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon);
2338 DEBUGFS_READ_WRITE_FILE_OPS(plcp_delta);
2339 DEBUGFS_READ_WRITE_FILE_OPS(rf_reset);
2340 DEBUGFS_READ_FILE_OPS(rxon_flags);
2341 DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
2342 DEBUGFS_WRITE_FILE_OPS(txfifo_flush);
2343 DEBUGFS_READ_FILE_OPS(ucode_bt_stats);
2344 DEBUGFS_READ_FILE_OPS(bt_traffic);
2345 DEBUGFS_READ_WRITE_FILE_OPS(protection_mode);
2346 DEBUGFS_READ_FILE_OPS(reply_tx_error);
2347 DEBUGFS_WRITE_FILE_OPS(echo_test);
2348 DEBUGFS_WRITE_FILE_OPS(fw_restart);
2349 #ifdef CONFIG_IWLWIFI_DEBUG
2350 DEBUGFS_READ_WRITE_FILE_OPS(log_event);
2351 #endif
2352 DEBUGFS_READ_WRITE_FILE_OPS(calib_disabled);
2353
2354 /*
2355 * Create the debugfs files and directories
2356 *
2357 */
2358 int iwl_dbgfs_register(struct iwl_priv *priv, struct dentry *dbgfs_dir)
2359 {
2360 struct dentry *dir_data, *dir_rf, *dir_debug;
2361
2362 priv->debugfs_dir = dbgfs_dir;
2363
2364 dir_data = debugfs_create_dir("data", dbgfs_dir);
2365 if (!dir_data)
2366 goto err;
2367 dir_rf = debugfs_create_dir("rf", dbgfs_dir);
2368 if (!dir_rf)
2369 goto err;
2370 dir_debug = debugfs_create_dir("debug", dbgfs_dir);
2371 if (!dir_debug)
2372 goto err;
2373
2374 DEBUGFS_ADD_FILE(nvm, dir_data, S_IRUSR);
2375 DEBUGFS_ADD_FILE(sram, dir_data, S_IWUSR | S_IRUSR);
2376 DEBUGFS_ADD_FILE(wowlan_sram, dir_data, S_IRUSR);
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);
2380 DEBUGFS_ADD_FILE(rx_handlers, dir_data, S_IWUSR | S_IRUSR);
2381 DEBUGFS_ADD_FILE(qos, dir_data, S_IRUSR);
2382 DEBUGFS_ADD_FILE(sleep_level_override, dir_data, S_IWUSR | S_IRUSR);
2383 DEBUGFS_ADD_FILE(current_sleep_command, dir_data, S_IRUSR);
2384 DEBUGFS_ADD_FILE(thermal_throttling, dir_data, S_IRUSR);
2385 DEBUGFS_ADD_FILE(disable_ht40, dir_data, S_IWUSR | S_IRUSR);
2386 DEBUGFS_ADD_FILE(temperature, dir_data, S_IRUSR);
2387
2388 DEBUGFS_ADD_FILE(power_save_status, dir_debug, S_IRUSR);
2389 DEBUGFS_ADD_FILE(clear_ucode_statistics, dir_debug, S_IWUSR);
2390 DEBUGFS_ADD_FILE(missed_beacon, dir_debug, S_IWUSR);
2391 DEBUGFS_ADD_FILE(plcp_delta, dir_debug, S_IWUSR | S_IRUSR);
2392 DEBUGFS_ADD_FILE(rf_reset, dir_debug, S_IWUSR | S_IRUSR);
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);
2396 DEBUGFS_ADD_FILE(txfifo_flush, dir_debug, S_IWUSR);
2397 DEBUGFS_ADD_FILE(protection_mode, dir_debug, S_IWUSR | S_IRUSR);
2398 DEBUGFS_ADD_FILE(sensitivity, dir_debug, S_IRUSR);
2399 DEBUGFS_ADD_FILE(chain_noise, dir_debug, S_IRUSR);
2400 DEBUGFS_ADD_FILE(ucode_tracing, dir_debug, S_IWUSR | S_IRUSR);
2401 DEBUGFS_ADD_FILE(ucode_bt_stats, dir_debug, S_IRUSR);
2402 DEBUGFS_ADD_FILE(reply_tx_error, dir_debug, S_IRUSR);
2403 DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR);
2404 DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR);
2405 DEBUGFS_ADD_FILE(echo_test, dir_debug, S_IWUSR);
2406 DEBUGFS_ADD_FILE(fw_restart, dir_debug, S_IWUSR);
2407 #ifdef CONFIG_IWLWIFI_DEBUG
2408 DEBUGFS_ADD_FILE(log_event, dir_debug, S_IWUSR | S_IRUSR);
2409 #endif
2410
2411 if (iwl_advanced_bt_coexist(priv))
2412 DEBUGFS_ADD_FILE(bt_traffic, dir_debug, S_IRUSR);
2413
2414 /* Calibrations disabled/enabled status*/
2415 DEBUGFS_ADD_FILE(calib_disabled, dir_rf, S_IWUSR | S_IRUSR);
2416
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];
2425 struct dentry *mac80211_dir, *dev_dir, *root_dir;
2426
2427 dev_dir = dbgfs_dir->d_parent;
2428 root_dir = dev_dir->d_parent;
2429 mac80211_dir = priv->hw->wiphy->debugfsdir;
2430
2431 snprintf(buf, 100, "../../%s/%s", root_dir->d_name.name,
2432 dev_dir->d_name.name);
2433
2434 if (!debugfs_create_symlink("iwlwifi", mac80211_dir, buf))
2435 goto err;
2436 }
2437
2438 return 0;
2439
2440 err:
2441 IWL_ERR(priv, "failed to create the dvm debugfs entries\n");
2442 return -ENOMEM;
2443 }
Linux with added FPC-III support