]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/net/wireless/iwlegacy/debug.c
iwlegacy: checkpatch.pl fixes
[~shefty/rdma-dev.git] / drivers / net / wireless / iwlegacy / debug.c
1 /******************************************************************************
2  *
3  * GPL LICENSE SUMMARY
4  *
5  * Copyright(c) 2008 - 2011 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 LICENSE.GPL.
23  *
24  * Contact Information:
25  *  Intel Linux Wireless <ilw@linux.intel.com>
26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27  *****************************************************************************/
28 #include <linux/ieee80211.h>
29 #include <net/mac80211.h>
30
31 #include "common.h"
32
33 /* create and remove of files */
34 #define DEBUGFS_ADD_FILE(name, parent, mode) do {                       \
35         if (!debugfs_create_file(#name, mode, parent, il,               \
36                          &il_dbgfs_##name##_ops))               \
37                 goto err;                                               \
38 } while (0)
39
40 #define DEBUGFS_ADD_BOOL(name, parent, ptr) do {                        \
41         struct dentry *__tmp;                                           \
42         __tmp = debugfs_create_bool(#name, S_IWUSR | S_IRUSR,           \
43                                     parent, ptr);                       \
44         if (IS_ERR(__tmp) || !__tmp)                                    \
45                 goto err;                                               \
46 } while (0)
47
48 #define DEBUGFS_ADD_X32(name, parent, ptr) do {                         \
49         struct dentry *__tmp;                                           \
50         __tmp = debugfs_create_x32(#name, S_IWUSR | S_IRUSR,            \
51                                    parent, ptr);                        \
52         if (IS_ERR(__tmp) || !__tmp)                                    \
53                 goto err;                                               \
54 } while (0)
55
56 /* file operation */
57 #define DEBUGFS_READ_FUNC(name)                                         \
58 static ssize_t il_dbgfs_##name##_read(struct file *file,               \
59                                         char __user *user_buf,          \
60                                         size_t count, loff_t *ppos);
61
62 #define DEBUGFS_WRITE_FUNC(name)                                        \
63 static ssize_t il_dbgfs_##name##_write(struct file *file,              \
64                                         const char __user *user_buf,    \
65                                         size_t count, loff_t *ppos);
66
67 static int
68 il_dbgfs_open_file_generic(struct inode *inode, struct file *file)
69 {
70         file->private_data = inode->i_private;
71         return 0;
72 }
73
74 #define DEBUGFS_READ_FILE_OPS(name)                             \
75         DEBUGFS_READ_FUNC(name);                                \
76 static const struct file_operations il_dbgfs_##name##_ops = {   \
77         .read = il_dbgfs_##name##_read,                         \
78         .open = il_dbgfs_open_file_generic,                     \
79         .llseek = generic_file_llseek,                          \
80 };
81
82 #define DEBUGFS_WRITE_FILE_OPS(name)                            \
83         DEBUGFS_WRITE_FUNC(name);                               \
84 static const struct file_operations il_dbgfs_##name##_ops = {   \
85         .write = il_dbgfs_##name##_write,                       \
86         .open = il_dbgfs_open_file_generic,                     \
87         .llseek = generic_file_llseek,                          \
88 };
89
90 #define DEBUGFS_READ_WRITE_FILE_OPS(name)                       \
91         DEBUGFS_READ_FUNC(name);                                \
92         DEBUGFS_WRITE_FUNC(name);                               \
93 static const struct file_operations il_dbgfs_##name##_ops = {   \
94         .write = il_dbgfs_##name##_write,                       \
95         .read = il_dbgfs_##name##_read,                         \
96         .open = il_dbgfs_open_file_generic,                     \
97         .llseek = generic_file_llseek,                          \
98 };
99
100 static ssize_t
101 il_dbgfs_tx_stats_read(struct file *file, char __user *user_buf, size_t count,
102                        loff_t *ppos)
103 {
104
105         struct il_priv *il = file->private_data;
106         char *buf;
107         int pos = 0;
108
109         int cnt;
110         ssize_t ret;
111         const size_t bufsz =
112             100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX);
113         buf = kzalloc(bufsz, GFP_KERNEL);
114         if (!buf)
115                 return -ENOMEM;
116         pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
117         for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
118                 pos +=
119                     scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
120                               il_get_mgmt_string(cnt), il->tx_stats.mgmt[cnt]);
121         }
122         pos += scnprintf(buf + pos, bufsz - pos, "Control\n");
123         for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
124                 pos +=
125                     scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
126                               il_get_ctrl_string(cnt), il->tx_stats.ctrl[cnt]);
127         }
128         pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
129         pos +=
130             scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
131                       il->tx_stats.data_cnt);
132         pos +=
133             scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
134                       il->tx_stats.data_bytes);
135         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
136         kfree(buf);
137         return ret;
138 }
139
140 static ssize_t
141 il_dbgfs_clear_traffic_stats_write(struct file *file,
142                                    const char __user *user_buf, size_t count,
143                                    loff_t *ppos)
144 {
145         struct il_priv *il = file->private_data;
146         u32 clear_flag;
147         char buf[8];
148         int buf_size;
149
150         memset(buf, 0, sizeof(buf));
151         buf_size = min(count, sizeof(buf) - 1);
152         if (copy_from_user(buf, user_buf, buf_size))
153                 return -EFAULT;
154         if (sscanf(buf, "%x", &clear_flag) != 1)
155                 return -EFAULT;
156         il_clear_traffic_stats(il);
157
158         return count;
159 }
160
161 static ssize_t
162 il_dbgfs_rx_stats_read(struct file *file, char __user *user_buf, size_t count,
163                        loff_t *ppos)
164 {
165
166         struct il_priv *il = file->private_data;
167         char *buf;
168         int pos = 0;
169         int cnt;
170         ssize_t ret;
171         const size_t bufsz =
172             100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX);
173         buf = kzalloc(bufsz, GFP_KERNEL);
174         if (!buf)
175                 return -ENOMEM;
176
177         pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
178         for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
179                 pos +=
180                     scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
181                               il_get_mgmt_string(cnt), il->rx_stats.mgmt[cnt]);
182         }
183         pos += scnprintf(buf + pos, bufsz - pos, "Control:\n");
184         for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
185                 pos +=
186                     scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n",
187                               il_get_ctrl_string(cnt), il->rx_stats.ctrl[cnt]);
188         }
189         pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
190         pos +=
191             scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
192                       il->rx_stats.data_cnt);
193         pos +=
194             scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
195                       il->rx_stats.data_bytes);
196
197         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
198         kfree(buf);
199         return ret;
200 }
201
202 #define BYTE1_MASK 0x000000ff;
203 #define BYTE2_MASK 0x0000ffff;
204 #define BYTE3_MASK 0x00ffffff;
205 static ssize_t
206 il_dbgfs_sram_read(struct file *file, char __user *user_buf, size_t count,
207                    loff_t *ppos)
208 {
209         u32 val;
210         char *buf;
211         ssize_t ret;
212         int i;
213         int pos = 0;
214         struct il_priv *il = file->private_data;
215         size_t bufsz;
216
217         /* default is to dump the entire data segment */
218         if (!il->dbgfs_sram_offset && !il->dbgfs_sram_len) {
219                 il->dbgfs_sram_offset = 0x800000;
220                 if (il->ucode_type == UCODE_INIT)
221                         il->dbgfs_sram_len = il->ucode_init_data.len;
222                 else
223                         il->dbgfs_sram_len = il->ucode_data.len;
224         }
225         bufsz = 30 + il->dbgfs_sram_len * sizeof(char) * 10;
226         buf = kmalloc(bufsz, GFP_KERNEL);
227         if (!buf)
228                 return -ENOMEM;
229         pos +=
230             scnprintf(buf + pos, bufsz - pos, "sram_len: 0x%x\n",
231                       il->dbgfs_sram_len);
232         pos +=
233             scnprintf(buf + pos, bufsz - pos, "sram_offset: 0x%x\n",
234                       il->dbgfs_sram_offset);
235         for (i = il->dbgfs_sram_len; i > 0; i -= 4) {
236                 val =
237                     il_read_targ_mem(il,
238                                      il->dbgfs_sram_offset +
239                                      il->dbgfs_sram_len - i);
240                 if (i < 4) {
241                         switch (i) {
242                         case 1:
243                                 val &= BYTE1_MASK;
244                                 break;
245                         case 2:
246                                 val &= BYTE2_MASK;
247                                 break;
248                         case 3:
249                                 val &= BYTE3_MASK;
250                                 break;
251                         }
252                 }
253                 if (!(i % 16))
254                         pos += scnprintf(buf + pos, bufsz - pos, "\n");
255                 pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val);
256         }
257         pos += scnprintf(buf + pos, bufsz - pos, "\n");
258
259         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
260         kfree(buf);
261         return ret;
262 }
263
264 static ssize_t
265 il_dbgfs_sram_write(struct file *file, const char __user *user_buf,
266                     size_t count, loff_t *ppos)
267 {
268         struct il_priv *il = file->private_data;
269         char buf[64];
270         int buf_size;
271         u32 offset, len;
272
273         memset(buf, 0, sizeof(buf));
274         buf_size = min(count, sizeof(buf) - 1);
275         if (copy_from_user(buf, user_buf, buf_size))
276                 return -EFAULT;
277
278         if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
279                 il->dbgfs_sram_offset = offset;
280                 il->dbgfs_sram_len = len;
281         } else {
282                 il->dbgfs_sram_offset = 0;
283                 il->dbgfs_sram_len = 0;
284         }
285
286         return count;
287 }
288
289 static ssize_t
290 il_dbgfs_stations_read(struct file *file, char __user *user_buf, size_t count,
291                        loff_t *ppos)
292 {
293         struct il_priv *il = file->private_data;
294         struct il_station_entry *station;
295         int max_sta = il->hw_params.max_stations;
296         char *buf;
297         int i, j, pos = 0;
298         ssize_t ret;
299         /* Add 30 for initial string */
300         const size_t bufsz = 30 + sizeof(char) * 500 * (il->num_stations);
301
302         buf = kmalloc(bufsz, GFP_KERNEL);
303         if (!buf)
304                 return -ENOMEM;
305
306         pos +=
307             scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
308                       il->num_stations);
309
310         for (i = 0; i < max_sta; i++) {
311                 station = &il->stations[i];
312                 if (!station->used)
313                         continue;
314                 pos +=
315                     scnprintf(buf + pos, bufsz - pos,
316                               "station %d - addr: %pM, flags: %#x\n", i,
317                               station->sta.sta.addr,
318                               station->sta.station_flags_msk);
319                 pos +=
320                     scnprintf(buf + pos, bufsz - pos,
321                               "TID\tseq_num\ttxq_id\tframes\ttfds\t");
322                 pos +=
323                     scnprintf(buf + pos, bufsz - pos,
324                               "start_idx\tbitmap\t\t\trate_n_flags\n");
325
326                 for (j = 0; j < MAX_TID_COUNT; j++) {
327                         pos +=
328                             scnprintf(buf + pos, bufsz - pos,
329                                       "%d:\t%#x\t%#x\t%u\t%u\t%u\t\t%#.16llx\t%#x",
330                                       j, station->tid[j].seq_number,
331                                       station->tid[j].agg.txq_id,
332                                       station->tid[j].agg.frame_count,
333                                       station->tid[j].tfds_in_queue,
334                                       station->tid[j].agg.start_idx,
335                                       station->tid[j].agg.bitmap,
336                                       station->tid[j].agg.rate_n_flags);
337
338                         if (station->tid[j].agg.wait_for_ba)
339                                 pos +=
340                                     scnprintf(buf + pos, bufsz - pos,
341                                               " - waitforba");
342                         pos += scnprintf(buf + pos, bufsz - pos, "\n");
343                 }
344
345                 pos += scnprintf(buf + pos, bufsz - pos, "\n");
346         }
347
348         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
349         kfree(buf);
350         return ret;
351 }
352
353 static ssize_t
354 il_dbgfs_nvm_read(struct file *file, char __user *user_buf, size_t count,
355                   loff_t *ppos)
356 {
357         ssize_t ret;
358         struct il_priv *il = file->private_data;
359         int pos = 0, ofs = 0, buf_size = 0;
360         const u8 *ptr;
361         char *buf;
362         u16 eeprom_ver;
363         size_t eeprom_len = il->cfg->base_params->eeprom_size;
364         buf_size = 4 * eeprom_len + 256;
365
366         if (eeprom_len % 16) {
367                 IL_ERR("NVM size is not multiple of 16.\n");
368                 return -ENODATA;
369         }
370
371         ptr = il->eeprom;
372         if (!ptr) {
373                 IL_ERR("Invalid EEPROM memory\n");
374                 return -ENOMEM;
375         }
376
377         /* 4 characters for byte 0xYY */
378         buf = kzalloc(buf_size, GFP_KERNEL);
379         if (!buf) {
380                 IL_ERR("Can not allocate Buffer\n");
381                 return -ENOMEM;
382         }
383         eeprom_ver = il_eeprom_query16(il, EEPROM_VERSION);
384         pos +=
385             scnprintf(buf + pos, buf_size - pos, "EEPROM " "version: 0x%x\n",
386                       eeprom_ver);
387         for (ofs = 0; ofs < eeprom_len; ofs += 16) {
388                 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x ", ofs);
389                 hex_dump_to_buffer(ptr + ofs, 16, 16, 2, buf + pos,
390                                    buf_size - pos, 0);
391                 pos += strlen(buf + pos);
392                 if (buf_size - pos > 0)
393                         buf[pos++] = '\n';
394         }
395
396         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
397         kfree(buf);
398         return ret;
399 }
400
401 static ssize_t
402 il_dbgfs_channels_read(struct file *file, char __user *user_buf, size_t count,
403                        loff_t *ppos)
404 {
405         struct il_priv *il = file->private_data;
406         struct ieee80211_channel *channels = NULL;
407         const struct ieee80211_supported_band *supp_band = NULL;
408         int pos = 0, i, bufsz = PAGE_SIZE;
409         char *buf;
410         ssize_t ret;
411
412         if (!test_bit(S_GEO_CONFIGURED, &il->status))
413                 return -EAGAIN;
414
415         buf = kzalloc(bufsz, GFP_KERNEL);
416         if (!buf) {
417                 IL_ERR("Can not allocate Buffer\n");
418                 return -ENOMEM;
419         }
420
421         supp_band = il_get_hw_mode(il, IEEE80211_BAND_2GHZ);
422         if (supp_band) {
423                 channels = supp_band->channels;
424
425                 pos +=
426                     scnprintf(buf + pos, bufsz - pos,
427                               "Displaying %d channels in 2.4GHz band 802.11bg):\n",
428                               supp_band->n_channels);
429
430                 for (i = 0; i < supp_band->n_channels; i++)
431                         pos +=
432                             scnprintf(buf + pos, bufsz - pos,
433                                       "%d: %ddBm: BSS%s%s, %s.\n",
434                                       channels[i].hw_value,
435                                       channels[i].max_power,
436                                       channels[i].
437                                       flags & IEEE80211_CHAN_RADAR ?
438                                       " (IEEE 802.11h required)" : "",
439                                       ((channels[i].
440                                         flags & IEEE80211_CHAN_NO_IBSS) ||
441                                        (channels[i].
442                                         flags & IEEE80211_CHAN_RADAR)) ? "" :
443                                       ", IBSS",
444                                       channels[i].
445                                       flags & IEEE80211_CHAN_PASSIVE_SCAN ?
446                                       "passive only" : "active/passive");
447         }
448         supp_band = il_get_hw_mode(il, IEEE80211_BAND_5GHZ);
449         if (supp_band) {
450                 channels = supp_band->channels;
451
452                 pos +=
453                     scnprintf(buf + pos, bufsz - pos,
454                               "Displaying %d channels in 5.2GHz band (802.11a)\n",
455                               supp_band->n_channels);
456
457                 for (i = 0; i < supp_band->n_channels; i++)
458                         pos +=
459                             scnprintf(buf + pos, bufsz - pos,
460                                       "%d: %ddBm: BSS%s%s, %s.\n",
461                                       channels[i].hw_value,
462                                       channels[i].max_power,
463                                       channels[i].
464                                       flags & IEEE80211_CHAN_RADAR ?
465                                       " (IEEE 802.11h required)" : "",
466                                       ((channels[i].
467                                         flags & IEEE80211_CHAN_NO_IBSS) ||
468                                        (channels[i].
469                                         flags & IEEE80211_CHAN_RADAR)) ? "" :
470                                       ", IBSS",
471                                       channels[i].
472                                       flags & IEEE80211_CHAN_PASSIVE_SCAN ?
473                                       "passive only" : "active/passive");
474         }
475         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
476         kfree(buf);
477         return ret;
478 }
479
480 static ssize_t
481 il_dbgfs_status_read(struct file *file, char __user *user_buf, size_t count,
482                      loff_t *ppos)
483 {
484
485         struct il_priv *il = file->private_data;
486         char buf[512];
487         int pos = 0;
488         const size_t bufsz = sizeof(buf);
489
490         pos +=
491             scnprintf(buf + pos, bufsz - pos, "S_HCMD_ACTIVE:\t %d\n",
492                       test_bit(S_HCMD_ACTIVE, &il->status));
493         pos +=
494             scnprintf(buf + pos, bufsz - pos, "S_INT_ENABLED:\t %d\n",
495                       test_bit(S_INT_ENABLED, &il->status));
496         pos +=
497             scnprintf(buf + pos, bufsz - pos, "S_RF_KILL_HW:\t %d\n",
498                       test_bit(S_RF_KILL_HW, &il->status));
499         pos +=
500             scnprintf(buf + pos, bufsz - pos, "S_CT_KILL:\t\t %d\n",
501                       test_bit(S_CT_KILL, &il->status));
502         pos +=
503             scnprintf(buf + pos, bufsz - pos, "S_INIT:\t\t %d\n",
504                       test_bit(S_INIT, &il->status));
505         pos +=
506             scnprintf(buf + pos, bufsz - pos, "S_ALIVE:\t\t %d\n",
507                       test_bit(S_ALIVE, &il->status));
508         pos +=
509             scnprintf(buf + pos, bufsz - pos, "S_READY:\t\t %d\n",
510                       test_bit(S_READY, &il->status));
511         pos +=
512             scnprintf(buf + pos, bufsz - pos, "S_TEMPERATURE:\t %d\n",
513                       test_bit(S_TEMPERATURE, &il->status));
514         pos +=
515             scnprintf(buf + pos, bufsz - pos, "S_GEO_CONFIGURED:\t %d\n",
516                       test_bit(S_GEO_CONFIGURED, &il->status));
517         pos +=
518             scnprintf(buf + pos, bufsz - pos, "S_EXIT_PENDING:\t %d\n",
519                       test_bit(S_EXIT_PENDING, &il->status));
520         pos +=
521             scnprintf(buf + pos, bufsz - pos, "S_STATS:\t %d\n",
522                       test_bit(S_STATS, &il->status));
523         pos +=
524             scnprintf(buf + pos, bufsz - pos, "S_SCANNING:\t %d\n",
525                       test_bit(S_SCANNING, &il->status));
526         pos +=
527             scnprintf(buf + pos, bufsz - pos, "S_SCAN_ABORTING:\t %d\n",
528                       test_bit(S_SCAN_ABORTING, &il->status));
529         pos +=
530             scnprintf(buf + pos, bufsz - pos, "S_SCAN_HW:\t\t %d\n",
531                       test_bit(S_SCAN_HW, &il->status));
532         pos +=
533             scnprintf(buf + pos, bufsz - pos, "S_POWER_PMI:\t %d\n",
534                       test_bit(S_POWER_PMI, &il->status));
535         pos +=
536             scnprintf(buf + pos, bufsz - pos, "S_FW_ERROR:\t %d\n",
537                       test_bit(S_FW_ERROR, &il->status));
538         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
539 }
540
541 static ssize_t
542 il_dbgfs_interrupt_read(struct file *file, char __user *user_buf, size_t count,
543                         loff_t *ppos)
544 {
545
546         struct il_priv *il = file->private_data;
547         int pos = 0;
548         int cnt = 0;
549         char *buf;
550         int bufsz = 24 * 64;    /* 24 items * 64 char per item */
551         ssize_t ret;
552
553         buf = kzalloc(bufsz, GFP_KERNEL);
554         if (!buf) {
555                 IL_ERR("Can not allocate Buffer\n");
556                 return -ENOMEM;
557         }
558
559         pos +=
560             scnprintf(buf + pos, bufsz - pos, "Interrupt Statistics Report:\n");
561
562         pos +=
563             scnprintf(buf + pos, bufsz - pos, "HW Error:\t\t\t %u\n",
564                       il->isr_stats.hw);
565         pos +=
566             scnprintf(buf + pos, bufsz - pos, "SW Error:\t\t\t %u\n",
567                       il->isr_stats.sw);
568         if (il->isr_stats.sw || il->isr_stats.hw) {
569                 pos +=
570                     scnprintf(buf + pos, bufsz - pos,
571                               "\tLast Restarting Code:  0x%X\n",
572                               il->isr_stats.err_code);
573         }
574 #ifdef CONFIG_IWLEGACY_DEBUG
575         pos +=
576             scnprintf(buf + pos, bufsz - pos, "Frame transmitted:\t\t %u\n",
577                       il->isr_stats.sch);
578         pos +=
579             scnprintf(buf + pos, bufsz - pos, "Alive interrupt:\t\t %u\n",
580                       il->isr_stats.alive);
581 #endif
582         pos +=
583             scnprintf(buf + pos, bufsz - pos,
584                       "HW RF KILL switch toggled:\t %u\n",
585                       il->isr_stats.rfkill);
586
587         pos +=
588             scnprintf(buf + pos, bufsz - pos, "CT KILL:\t\t\t %u\n",
589                       il->isr_stats.ctkill);
590
591         pos +=
592             scnprintf(buf + pos, bufsz - pos, "Wakeup Interrupt:\t\t %u\n",
593                       il->isr_stats.wakeup);
594
595         pos +=
596             scnprintf(buf + pos, bufsz - pos, "Rx command responses:\t\t %u\n",
597                       il->isr_stats.rx);
598         for (cnt = 0; cnt < IL_CN_MAX; cnt++) {
599                 if (il->isr_stats.handlers[cnt] > 0)
600                         pos +=
601                             scnprintf(buf + pos, bufsz - pos,
602                                       "\tRx handler[%36s]:\t\t %u\n",
603                                       il_get_cmd_string(cnt),
604                                       il->isr_stats.handlers[cnt]);
605         }
606
607         pos +=
608             scnprintf(buf + pos, bufsz - pos, "Tx/FH interrupt:\t\t %u\n",
609                       il->isr_stats.tx);
610
611         pos +=
612             scnprintf(buf + pos, bufsz - pos, "Unexpected INTA:\t\t %u\n",
613                       il->isr_stats.unhandled);
614
615         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
616         kfree(buf);
617         return ret;
618 }
619
620 static ssize_t
621 il_dbgfs_interrupt_write(struct file *file, const char __user *user_buf,
622                          size_t count, loff_t *ppos)
623 {
624         struct il_priv *il = file->private_data;
625         char buf[8];
626         int buf_size;
627         u32 reset_flag;
628
629         memset(buf, 0, sizeof(buf));
630         buf_size = min(count, sizeof(buf) - 1);
631         if (copy_from_user(buf, user_buf, buf_size))
632                 return -EFAULT;
633         if (sscanf(buf, "%x", &reset_flag) != 1)
634                 return -EFAULT;
635         if (reset_flag == 0)
636                 il_clear_isr_stats(il);
637
638         return count;
639 }
640
641 static ssize_t
642 il_dbgfs_qos_read(struct file *file, char __user *user_buf, size_t count,
643                   loff_t *ppos)
644 {
645         struct il_priv *il = file->private_data;
646         struct il_rxon_context *ctx = &il->ctx;
647         int pos = 0, i;
648         char buf[256];
649         const size_t bufsz = sizeof(buf);
650
651         pos += scnprintf(buf + pos, bufsz - pos, "context %d:\n", ctx->ctxid);
652         for (i = 0; i < AC_NUM; i++) {
653                 pos +=
654                     scnprintf(buf + pos, bufsz - pos,
655                               "\tcw_min\tcw_max\taifsn\ttxop\n");
656                 pos +=
657                     scnprintf(buf + pos, bufsz - pos,
658                               "AC[%d]\t%u\t%u\t%u\t%u\n", i,
659                               ctx->qos_data.def_qos_parm.ac[i].cw_min,
660                               ctx->qos_data.def_qos_parm.ac[i].cw_max,
661                               ctx->qos_data.def_qos_parm.ac[i].aifsn,
662                               ctx->qos_data.def_qos_parm.ac[i].edca_txop);
663         }
664
665         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
666 }
667
668 static ssize_t
669 il_dbgfs_disable_ht40_write(struct file *file, const char __user *user_buf,
670                             size_t count, loff_t *ppos)
671 {
672         struct il_priv *il = file->private_data;
673         char buf[8];
674         int buf_size;
675         int ht40;
676
677         memset(buf, 0, sizeof(buf));
678         buf_size = min(count, sizeof(buf) - 1);
679         if (copy_from_user(buf, user_buf, buf_size))
680                 return -EFAULT;
681         if (sscanf(buf, "%d", &ht40) != 1)
682                 return -EFAULT;
683         if (!il_is_any_associated(il))
684                 il->disable_ht40 = ht40 ? true : false;
685         else {
686                 IL_ERR("Sta associated with AP - "
687                        "Change to 40MHz channel support is not allowed\n");
688                 return -EINVAL;
689         }
690
691         return count;
692 }
693
694 static ssize_t
695 il_dbgfs_disable_ht40_read(struct file *file, char __user *user_buf,
696                            size_t count, loff_t *ppos)
697 {
698         struct il_priv *il = file->private_data;
699         char buf[100];
700         int pos = 0;
701         const size_t bufsz = sizeof(buf);
702
703         pos +=
704             scnprintf(buf + pos, bufsz - pos, "11n 40MHz Mode: %s\n",
705                       il->disable_ht40 ? "Disabled" : "Enabled");
706         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
707 }
708
709 DEBUGFS_READ_WRITE_FILE_OPS(sram);
710 DEBUGFS_READ_FILE_OPS(nvm);
711 DEBUGFS_READ_FILE_OPS(stations);
712 DEBUGFS_READ_FILE_OPS(channels);
713 DEBUGFS_READ_FILE_OPS(status);
714 DEBUGFS_READ_WRITE_FILE_OPS(interrupt);
715 DEBUGFS_READ_FILE_OPS(qos);
716 DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40);
717
718 static ssize_t
719 il_dbgfs_traffic_log_read(struct file *file, char __user *user_buf,
720                           size_t count, loff_t *ppos)
721 {
722         struct il_priv *il = file->private_data;
723         int pos = 0, ofs = 0;
724         int cnt = 0, entry;
725         struct il_tx_queue *txq;
726         struct il_queue *q;
727         struct il_rx_queue *rxq = &il->rxq;
728         char *buf;
729         int bufsz =
730             ((IL_TRAFFIC_ENTRIES * IL_TRAFFIC_ENTRY_SIZE * 64) * 2) +
731             (il->cfg->base_params->num_of_queues * 32 * 8) + 400;
732         const u8 *ptr;
733         ssize_t ret;
734
735         if (!il->txq) {
736                 IL_ERR("txq not ready\n");
737                 return -EAGAIN;
738         }
739         buf = kzalloc(bufsz, GFP_KERNEL);
740         if (!buf) {
741                 IL_ERR("Can not allocate buffer\n");
742                 return -ENOMEM;
743         }
744         pos += scnprintf(buf + pos, bufsz - pos, "Tx Queue\n");
745         for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
746                 txq = &il->txq[cnt];
747                 q = &txq->q;
748                 pos +=
749                     scnprintf(buf + pos, bufsz - pos,
750                               "q[%d]: read_ptr: %u, write_ptr: %u\n", cnt,
751                               q->read_ptr, q->write_ptr);
752         }
753         if (il->tx_traffic && (il_debug_level & IL_DL_TX)) {
754                 ptr = il->tx_traffic;
755                 pos +=
756                     scnprintf(buf + pos, bufsz - pos, "Tx Traffic idx: %u\n",
757                               il->tx_traffic_idx);
758                 for (cnt = 0, ofs = 0; cnt < IL_TRAFFIC_ENTRIES; cnt++) {
759                         for (entry = 0; entry < IL_TRAFFIC_ENTRY_SIZE / 16;
760                              entry++, ofs += 16) {
761                                 pos +=
762                                     scnprintf(buf + pos, bufsz - pos, "0x%.4x ",
763                                               ofs);
764                                 hex_dump_to_buffer(ptr + ofs, 16, 16, 2,
765                                                    buf + pos, bufsz - pos, 0);
766                                 pos += strlen(buf + pos);
767                                 if (bufsz - pos > 0)
768                                         buf[pos++] = '\n';
769                         }
770                 }
771         }
772
773         pos += scnprintf(buf + pos, bufsz - pos, "Rx Queue\n");
774         pos +=
775             scnprintf(buf + pos, bufsz - pos, "read: %u, write: %u\n",
776                       rxq->read, rxq->write);
777
778         if (il->rx_traffic && (il_debug_level & IL_DL_RX)) {
779                 ptr = il->rx_traffic;
780                 pos +=
781                     scnprintf(buf + pos, bufsz - pos, "Rx Traffic idx: %u\n",
782                               il->rx_traffic_idx);
783                 for (cnt = 0, ofs = 0; cnt < IL_TRAFFIC_ENTRIES; cnt++) {
784                         for (entry = 0; entry < IL_TRAFFIC_ENTRY_SIZE / 16;
785                              entry++, ofs += 16) {
786                                 pos +=
787                                     scnprintf(buf + pos, bufsz - pos, "0x%.4x ",
788                                               ofs);
789                                 hex_dump_to_buffer(ptr + ofs, 16, 16, 2,
790                                                    buf + pos, bufsz - pos, 0);
791                                 pos += strlen(buf + pos);
792                                 if (bufsz - pos > 0)
793                                         buf[pos++] = '\n';
794                         }
795                 }
796         }
797
798         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
799         kfree(buf);
800         return ret;
801 }
802
803 static ssize_t
804 il_dbgfs_traffic_log_write(struct file *file, const char __user *user_buf,
805                            size_t count, loff_t *ppos)
806 {
807         struct il_priv *il = file->private_data;
808         char buf[8];
809         int buf_size;
810         int traffic_log;
811
812         memset(buf, 0, sizeof(buf));
813         buf_size = min(count, sizeof(buf) - 1);
814         if (copy_from_user(buf, user_buf, buf_size))
815                 return -EFAULT;
816         if (sscanf(buf, "%d", &traffic_log) != 1)
817                 return -EFAULT;
818         if (traffic_log == 0)
819                 il_reset_traffic_log(il);
820
821         return count;
822 }
823
824 static ssize_t
825 il_dbgfs_tx_queue_read(struct file *file, char __user *user_buf, size_t count,
826                        loff_t *ppos)
827 {
828
829         struct il_priv *il = file->private_data;
830         struct il_tx_queue *txq;
831         struct il_queue *q;
832         char *buf;
833         int pos = 0;
834         int cnt;
835         int ret;
836         const size_t bufsz =
837             sizeof(char) * 64 * il->cfg->base_params->num_of_queues;
838
839         if (!il->txq) {
840                 IL_ERR("txq not ready\n");
841                 return -EAGAIN;
842         }
843         buf = kzalloc(bufsz, GFP_KERNEL);
844         if (!buf)
845                 return -ENOMEM;
846
847         for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
848                 txq = &il->txq[cnt];
849                 q = &txq->q;
850                 pos +=
851                     scnprintf(buf + pos, bufsz - pos,
852                               "hwq %.2d: read=%u write=%u stop=%d"
853                               " swq_id=%#.2x (ac %d/hwq %d)\n", cnt,
854                               q->read_ptr, q->write_ptr,
855                               !!test_bit(cnt, il->queue_stopped),
856                               txq->swq_id, txq->swq_id & 3,
857                               (txq->swq_id >> 2) & 0x1f);
858                 if (cnt >= 4)
859                         continue;
860                 /* for the ACs, display the stop count too */
861                 pos +=
862                     scnprintf(buf + pos, bufsz - pos,
863                               "        stop-count: %d\n",
864                               atomic_read(&il->queue_stop_count[cnt]));
865         }
866         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
867         kfree(buf);
868         return ret;
869 }
870
871 static ssize_t
872 il_dbgfs_rx_queue_read(struct file *file, char __user *user_buf, size_t count,
873                        loff_t *ppos)
874 {
875
876         struct il_priv *il = file->private_data;
877         struct il_rx_queue *rxq = &il->rxq;
878         char buf[256];
879         int pos = 0;
880         const size_t bufsz = sizeof(buf);
881
882         pos += scnprintf(buf + pos, bufsz - pos, "read: %u\n", rxq->read);
883         pos += scnprintf(buf + pos, bufsz - pos, "write: %u\n", rxq->write);
884         pos +=
885             scnprintf(buf + pos, bufsz - pos, "free_count: %u\n",
886                       rxq->free_count);
887         if (rxq->rb_stts) {
888                 pos +=
889                     scnprintf(buf + pos, bufsz - pos, "closed_rb_num: %u\n",
890                               le16_to_cpu(rxq->rb_stts->
891                                           closed_rb_num) & 0x0FFF);
892         } else {
893                 pos +=
894                     scnprintf(buf + pos, bufsz - pos,
895                               "closed_rb_num: Not Allocated\n");
896         }
897         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
898 }
899
900 static ssize_t
901 il_dbgfs_ucode_rx_stats_read(struct file *file, char __user *user_buf,
902                              size_t count, loff_t *ppos)
903 {
904         struct il_priv *il = file->private_data;
905         return il->cfg->ops->lib->debugfs_ops.rx_stats_read(file, user_buf,
906                                                             count, ppos);
907 }
908
909 static ssize_t
910 il_dbgfs_ucode_tx_stats_read(struct file *file, char __user *user_buf,
911                              size_t count, loff_t *ppos)
912 {
913         struct il_priv *il = file->private_data;
914         return il->cfg->ops->lib->debugfs_ops.tx_stats_read(file, user_buf,
915                                                             count, ppos);
916 }
917
918 static ssize_t
919 il_dbgfs_ucode_general_stats_read(struct file *file, char __user *user_buf,
920                                   size_t count, loff_t *ppos)
921 {
922         struct il_priv *il = file->private_data;
923         return il->cfg->ops->lib->debugfs_ops.general_stats_read(file, user_buf,
924                                                                  count, ppos);
925 }
926
927 static ssize_t
928 il_dbgfs_sensitivity_read(struct file *file, char __user *user_buf,
929                           size_t count, loff_t *ppos)
930 {
931
932         struct il_priv *il = file->private_data;
933         int pos = 0;
934         int cnt = 0;
935         char *buf;
936         int bufsz = sizeof(struct il_sensitivity_data) * 4 + 100;
937         ssize_t ret;
938         struct il_sensitivity_data *data;
939
940         data = &il->sensitivity_data;
941         buf = kzalloc(bufsz, GFP_KERNEL);
942         if (!buf) {
943                 IL_ERR("Can not allocate Buffer\n");
944                 return -ENOMEM;
945         }
946
947         pos +=
948             scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm:\t\t\t %u\n",
949                       data->auto_corr_ofdm);
950         pos +=
951             scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc:\t\t %u\n",
952                       data->auto_corr_ofdm_mrc);
953         pos +=
954             scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_x1:\t\t %u\n",
955                       data->auto_corr_ofdm_x1);
956         pos +=
957             scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc_x1:\t\t %u\n",
958                       data->auto_corr_ofdm_mrc_x1);
959         pos +=
960             scnprintf(buf + pos, bufsz - pos, "auto_corr_cck:\t\t\t %u\n",
961                       data->auto_corr_cck);
962         pos +=
963             scnprintf(buf + pos, bufsz - pos, "auto_corr_cck_mrc:\t\t %u\n",
964                       data->auto_corr_cck_mrc);
965         pos +=
966             scnprintf(buf + pos, bufsz - pos,
967                       "last_bad_plcp_cnt_ofdm:\t\t %u\n",
968                       data->last_bad_plcp_cnt_ofdm);
969         pos +=
970             scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_ofdm:\t\t %u\n",
971                       data->last_fa_cnt_ofdm);
972         pos +=
973             scnprintf(buf + pos, bufsz - pos, "last_bad_plcp_cnt_cck:\t\t %u\n",
974                       data->last_bad_plcp_cnt_cck);
975         pos +=
976             scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_cck:\t\t %u\n",
977                       data->last_fa_cnt_cck);
978         pos +=
979             scnprintf(buf + pos, bufsz - pos, "nrg_curr_state:\t\t\t %u\n",
980                       data->nrg_curr_state);
981         pos +=
982             scnprintf(buf + pos, bufsz - pos, "nrg_prev_state:\t\t\t %u\n",
983                       data->nrg_prev_state);
984         pos += scnprintf(buf + pos, bufsz - pos, "nrg_value:\t\t\t");
985         for (cnt = 0; cnt < 10; cnt++) {
986                 pos +=
987                     scnprintf(buf + pos, bufsz - pos, " %u",
988                               data->nrg_value[cnt]);
989         }
990         pos += scnprintf(buf + pos, bufsz - pos, "\n");
991         pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_rssi:\t\t");
992         for (cnt = 0; cnt < NRG_NUM_PREV_STAT_L; cnt++) {
993                 pos +=
994                     scnprintf(buf + pos, bufsz - pos, " %u",
995                               data->nrg_silence_rssi[cnt]);
996         }
997         pos += scnprintf(buf + pos, bufsz - pos, "\n");
998         pos +=
999             scnprintf(buf + pos, bufsz - pos, "nrg_silence_ref:\t\t %u\n",
1000                       data->nrg_silence_ref);
1001         pos +=
1002             scnprintf(buf + pos, bufsz - pos, "nrg_energy_idx:\t\t\t %u\n",
1003                       data->nrg_energy_idx);
1004         pos +=
1005             scnprintf(buf + pos, bufsz - pos, "nrg_silence_idx:\t\t %u\n",
1006                       data->nrg_silence_idx);
1007         pos +=
1008             scnprintf(buf + pos, bufsz - pos, "nrg_th_cck:\t\t\t %u\n",
1009                       data->nrg_th_cck);
1010         pos +=
1011             scnprintf(buf + pos, bufsz - pos,
1012                       "nrg_auto_corr_silence_diff:\t %u\n",
1013                       data->nrg_auto_corr_silence_diff);
1014         pos +=
1015             scnprintf(buf + pos, bufsz - pos, "num_in_cck_no_fa:\t\t %u\n",
1016                       data->num_in_cck_no_fa);
1017         pos +=
1018             scnprintf(buf + pos, bufsz - pos, "nrg_th_ofdm:\t\t\t %u\n",
1019                       data->nrg_th_ofdm);
1020
1021         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1022         kfree(buf);
1023         return ret;
1024 }
1025
1026 static ssize_t
1027 il_dbgfs_chain_noise_read(struct file *file, char __user *user_buf,
1028                           size_t count, loff_t *ppos)
1029 {
1030
1031         struct il_priv *il = file->private_data;
1032         int pos = 0;
1033         int cnt = 0;
1034         char *buf;
1035         int bufsz = sizeof(struct il_chain_noise_data) * 4 + 100;
1036         ssize_t ret;
1037         struct il_chain_noise_data *data;
1038
1039         data = &il->chain_noise_data;
1040         buf = kzalloc(bufsz, GFP_KERNEL);
1041         if (!buf) {
1042                 IL_ERR("Can not allocate Buffer\n");
1043                 return -ENOMEM;
1044         }
1045
1046         pos +=
1047             scnprintf(buf + pos, bufsz - pos, "active_chains:\t\t\t %u\n",
1048                       data->active_chains);
1049         pos +=
1050             scnprintf(buf + pos, bufsz - pos, "chain_noise_a:\t\t\t %u\n",
1051                       data->chain_noise_a);
1052         pos +=
1053             scnprintf(buf + pos, bufsz - pos, "chain_noise_b:\t\t\t %u\n",
1054                       data->chain_noise_b);
1055         pos +=
1056             scnprintf(buf + pos, bufsz - pos, "chain_noise_c:\t\t\t %u\n",
1057                       data->chain_noise_c);
1058         pos +=
1059             scnprintf(buf + pos, bufsz - pos, "chain_signal_a:\t\t\t %u\n",
1060                       data->chain_signal_a);
1061         pos +=
1062             scnprintf(buf + pos, bufsz - pos, "chain_signal_b:\t\t\t %u\n",
1063                       data->chain_signal_b);
1064         pos +=
1065             scnprintf(buf + pos, bufsz - pos, "chain_signal_c:\t\t\t %u\n",
1066                       data->chain_signal_c);
1067         pos +=
1068             scnprintf(buf + pos, bufsz - pos, "beacon_count:\t\t\t %u\n",
1069                       data->beacon_count);
1070
1071         pos += scnprintf(buf + pos, bufsz - pos, "disconn_array:\t\t\t");
1072         for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
1073                 pos +=
1074                     scnprintf(buf + pos, bufsz - pos, " %u",
1075                               data->disconn_array[cnt]);
1076         }
1077         pos += scnprintf(buf + pos, bufsz - pos, "\n");
1078         pos += scnprintf(buf + pos, bufsz - pos, "delta_gain_code:\t\t");
1079         for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) {
1080                 pos +=
1081                     scnprintf(buf + pos, bufsz - pos, " %u",
1082                               data->delta_gain_code[cnt]);
1083         }
1084         pos += scnprintf(buf + pos, bufsz - pos, "\n");
1085         pos +=
1086             scnprintf(buf + pos, bufsz - pos, "radio_write:\t\t\t %u\n",
1087                       data->radio_write);
1088         pos +=
1089             scnprintf(buf + pos, bufsz - pos, "state:\t\t\t\t %u\n",
1090                       data->state);
1091
1092         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1093         kfree(buf);
1094         return ret;
1095 }
1096
1097 static ssize_t
1098 il_dbgfs_power_save_status_read(struct file *file, char __user *user_buf,
1099                                 size_t count, loff_t *ppos)
1100 {
1101         struct il_priv *il = file->private_data;
1102         char buf[60];
1103         int pos = 0;
1104         const size_t bufsz = sizeof(buf);
1105         u32 pwrsave_status;
1106
1107         pwrsave_status =
1108             _il_rd(il, CSR_GP_CNTRL) & CSR_GP_REG_POWER_SAVE_STATUS_MSK;
1109
1110         pos += scnprintf(buf + pos, bufsz - pos, "Power Save Status: ");
1111         pos +=
1112             scnprintf(buf + pos, bufsz - pos, "%s\n",
1113                       (pwrsave_status == CSR_GP_REG_NO_POWER_SAVE) ? "none" :
1114                       (pwrsave_status == CSR_GP_REG_MAC_POWER_SAVE) ? "MAC" :
1115                       (pwrsave_status == CSR_GP_REG_PHY_POWER_SAVE) ? "PHY" :
1116                       "error");
1117
1118         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1119 }
1120
1121 static ssize_t
1122 il_dbgfs_clear_ucode_stats_write(struct file *file,
1123                                  const char __user *user_buf, size_t count,
1124                                  loff_t *ppos)
1125 {
1126         struct il_priv *il = file->private_data;
1127         char buf[8];
1128         int buf_size;
1129         int clear;
1130
1131         memset(buf, 0, sizeof(buf));
1132         buf_size = min(count, sizeof(buf) - 1);
1133         if (copy_from_user(buf, user_buf, buf_size))
1134                 return -EFAULT;
1135         if (sscanf(buf, "%d", &clear) != 1)
1136                 return -EFAULT;
1137
1138         /* make request to uCode to retrieve stats information */
1139         mutex_lock(&il->mutex);
1140         il_send_stats_request(il, CMD_SYNC, true);
1141         mutex_unlock(&il->mutex);
1142
1143         return count;
1144 }
1145
1146 static ssize_t
1147 il_dbgfs_rxon_flags_read(struct file *file, char __user *user_buf,
1148                          size_t count, loff_t *ppos)
1149 {
1150
1151         struct il_priv *il = file->private_data;
1152         int len = 0;
1153         char buf[20];
1154
1155         len = sprintf(buf, "0x%04X\n", le32_to_cpu(il->ctx.active.flags));
1156         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1157 }
1158
1159 static ssize_t
1160 il_dbgfs_rxon_filter_flags_read(struct file *file, char __user *user_buf,
1161                                 size_t count, loff_t *ppos)
1162 {
1163
1164         struct il_priv *il = file->private_data;
1165         int len = 0;
1166         char buf[20];
1167
1168         len =
1169             sprintf(buf, "0x%04X\n", le32_to_cpu(il->ctx.active.filter_flags));
1170         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1171 }
1172
1173 static ssize_t
1174 il_dbgfs_fh_reg_read(struct file *file, char __user *user_buf, size_t count,
1175                      loff_t *ppos)
1176 {
1177         struct il_priv *il = file->private_data;
1178         char *buf;
1179         int pos = 0;
1180         ssize_t ret = -EFAULT;
1181
1182         if (il->cfg->ops->lib->dump_fh) {
1183                 ret = pos = il->cfg->ops->lib->dump_fh(il, &buf, true);
1184                 if (buf) {
1185                         ret =
1186                             simple_read_from_buffer(user_buf, count, ppos, buf,
1187                                                     pos);
1188                         kfree(buf);
1189                 }
1190         }
1191
1192         return ret;
1193 }
1194
1195 static ssize_t
1196 il_dbgfs_missed_beacon_read(struct file *file, char __user *user_buf,
1197                             size_t count, loff_t *ppos)
1198 {
1199
1200         struct il_priv *il = file->private_data;
1201         int pos = 0;
1202         char buf[12];
1203         const size_t bufsz = sizeof(buf);
1204
1205         pos +=
1206             scnprintf(buf + pos, bufsz - pos, "%d\n",
1207                       il->missed_beacon_threshold);
1208
1209         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1210 }
1211
1212 static ssize_t
1213 il_dbgfs_missed_beacon_write(struct file *file, const char __user *user_buf,
1214                              size_t count, loff_t *ppos)
1215 {
1216         struct il_priv *il = file->private_data;
1217         char buf[8];
1218         int buf_size;
1219         int missed;
1220
1221         memset(buf, 0, sizeof(buf));
1222         buf_size = min(count, sizeof(buf) - 1);
1223         if (copy_from_user(buf, user_buf, buf_size))
1224                 return -EFAULT;
1225         if (sscanf(buf, "%d", &missed) != 1)
1226                 return -EINVAL;
1227
1228         if (missed < IL_MISSED_BEACON_THRESHOLD_MIN ||
1229             missed > IL_MISSED_BEACON_THRESHOLD_MAX)
1230                 il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
1231         else
1232                 il->missed_beacon_threshold = missed;
1233
1234         return count;
1235 }
1236
1237 static ssize_t
1238 il_dbgfs_force_reset_read(struct file *file, char __user *user_buf,
1239                           size_t count, loff_t *ppos)
1240 {
1241
1242         struct il_priv *il = file->private_data;
1243         int pos = 0;
1244         char buf[300];
1245         const size_t bufsz = sizeof(buf);
1246         struct il_force_reset *force_reset;
1247
1248         force_reset = &il->force_reset;
1249
1250         pos +=
1251             scnprintf(buf + pos, bufsz - pos, "\tnumber of reset request: %d\n",
1252                       force_reset->reset_request_count);
1253         pos +=
1254             scnprintf(buf + pos, bufsz - pos,
1255                       "\tnumber of reset request success: %d\n",
1256                       force_reset->reset_success_count);
1257         pos +=
1258             scnprintf(buf + pos, bufsz - pos,
1259                       "\tnumber of reset request reject: %d\n",
1260                       force_reset->reset_reject_count);
1261         pos +=
1262             scnprintf(buf + pos, bufsz - pos, "\treset duration: %lu\n",
1263                       force_reset->reset_duration);
1264
1265         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1266 }
1267
1268 static ssize_t
1269 il_dbgfs_force_reset_write(struct file *file, const char __user *user_buf,
1270                            size_t count, loff_t *ppos)
1271 {
1272
1273         int ret;
1274         struct il_priv *il = file->private_data;
1275
1276         ret = il_force_reset(il, true);
1277
1278         return ret ? ret : count;
1279 }
1280
1281 static ssize_t
1282 il_dbgfs_wd_timeout_write(struct file *file, const char __user *user_buf,
1283                           size_t count, loff_t *ppos)
1284 {
1285
1286         struct il_priv *il = file->private_data;
1287         char buf[8];
1288         int buf_size;
1289         int timeout;
1290
1291         memset(buf, 0, sizeof(buf));
1292         buf_size = min(count, sizeof(buf) - 1);
1293         if (copy_from_user(buf, user_buf, buf_size))
1294                 return -EFAULT;
1295         if (sscanf(buf, "%d", &timeout) != 1)
1296                 return -EINVAL;
1297         if (timeout < 0 || timeout > IL_MAX_WD_TIMEOUT)
1298                 timeout = IL_DEF_WD_TIMEOUT;
1299
1300         il->cfg->base_params->wd_timeout = timeout;
1301         il_setup_watchdog(il);
1302         return count;
1303 }
1304
1305 DEBUGFS_READ_FILE_OPS(rx_stats);
1306 DEBUGFS_READ_FILE_OPS(tx_stats);
1307 DEBUGFS_READ_WRITE_FILE_OPS(traffic_log);
1308 DEBUGFS_READ_FILE_OPS(rx_queue);
1309 DEBUGFS_READ_FILE_OPS(tx_queue);
1310 DEBUGFS_READ_FILE_OPS(ucode_rx_stats);
1311 DEBUGFS_READ_FILE_OPS(ucode_tx_stats);
1312 DEBUGFS_READ_FILE_OPS(ucode_general_stats);
1313 DEBUGFS_READ_FILE_OPS(sensitivity);
1314 DEBUGFS_READ_FILE_OPS(chain_noise);
1315 DEBUGFS_READ_FILE_OPS(power_save_status);
1316 DEBUGFS_WRITE_FILE_OPS(clear_ucode_stats);
1317 DEBUGFS_WRITE_FILE_OPS(clear_traffic_stats);
1318 DEBUGFS_READ_FILE_OPS(fh_reg);
1319 DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon);
1320 DEBUGFS_READ_WRITE_FILE_OPS(force_reset);
1321 DEBUGFS_READ_FILE_OPS(rxon_flags);
1322 DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
1323 DEBUGFS_WRITE_FILE_OPS(wd_timeout);
1324
1325 /*
1326  * Create the debugfs files and directories
1327  *
1328  */
1329 int
1330 il_dbgfs_register(struct il_priv *il, const char *name)
1331 {
1332         struct dentry *phyd = il->hw->wiphy->debugfsdir;
1333         struct dentry *dir_drv, *dir_data, *dir_rf, *dir_debug;
1334
1335         dir_drv = debugfs_create_dir(name, phyd);
1336         if (!dir_drv)
1337                 return -ENOMEM;
1338
1339         il->debugfs_dir = dir_drv;
1340
1341         dir_data = debugfs_create_dir("data", dir_drv);
1342         if (!dir_data)
1343                 goto err;
1344         dir_rf = debugfs_create_dir("rf", dir_drv);
1345         if (!dir_rf)
1346                 goto err;
1347         dir_debug = debugfs_create_dir("debug", dir_drv);
1348         if (!dir_debug)
1349                 goto err;
1350
1351         DEBUGFS_ADD_FILE(nvm, dir_data, S_IRUSR);
1352         DEBUGFS_ADD_FILE(sram, dir_data, S_IWUSR | S_IRUSR);
1353         DEBUGFS_ADD_FILE(stations, dir_data, S_IRUSR);
1354         DEBUGFS_ADD_FILE(channels, dir_data, S_IRUSR);
1355         DEBUGFS_ADD_FILE(status, dir_data, S_IRUSR);
1356         DEBUGFS_ADD_FILE(interrupt, dir_data, S_IWUSR | S_IRUSR);
1357         DEBUGFS_ADD_FILE(qos, dir_data, S_IRUSR);
1358         DEBUGFS_ADD_FILE(disable_ht40, dir_data, S_IWUSR | S_IRUSR);
1359         DEBUGFS_ADD_FILE(rx_stats, dir_debug, S_IRUSR);
1360         DEBUGFS_ADD_FILE(tx_stats, dir_debug, S_IRUSR);
1361         DEBUGFS_ADD_FILE(traffic_log, dir_debug, S_IWUSR | S_IRUSR);
1362         DEBUGFS_ADD_FILE(rx_queue, dir_debug, S_IRUSR);
1363         DEBUGFS_ADD_FILE(tx_queue, dir_debug, S_IRUSR);
1364         DEBUGFS_ADD_FILE(power_save_status, dir_debug, S_IRUSR);
1365         DEBUGFS_ADD_FILE(clear_ucode_stats, dir_debug, S_IWUSR);
1366         DEBUGFS_ADD_FILE(clear_traffic_stats, dir_debug, S_IWUSR);
1367         DEBUGFS_ADD_FILE(fh_reg, dir_debug, S_IRUSR);
1368         DEBUGFS_ADD_FILE(missed_beacon, dir_debug, S_IWUSR);
1369         DEBUGFS_ADD_FILE(force_reset, dir_debug, S_IWUSR | S_IRUSR);
1370         DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, S_IRUSR);
1371         DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, S_IRUSR);
1372         DEBUGFS_ADD_FILE(ucode_general_stats, dir_debug, S_IRUSR);
1373
1374         if (il->cfg->base_params->sensitivity_calib_by_driver)
1375                 DEBUGFS_ADD_FILE(sensitivity, dir_debug, S_IRUSR);
1376         if (il->cfg->base_params->chain_noise_calib_by_driver)
1377                 DEBUGFS_ADD_FILE(chain_noise, dir_debug, S_IRUSR);
1378         DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR);
1379         DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR);
1380         DEBUGFS_ADD_FILE(wd_timeout, dir_debug, S_IWUSR);
1381         if (il->cfg->base_params->sensitivity_calib_by_driver)
1382                 DEBUGFS_ADD_BOOL(disable_sensitivity, dir_rf,
1383                                  &il->disable_sens_cal);
1384         if (il->cfg->base_params->chain_noise_calib_by_driver)
1385                 DEBUGFS_ADD_BOOL(disable_chain_noise, dir_rf,
1386                                  &il->disable_chain_noise_cal);
1387         DEBUGFS_ADD_BOOL(disable_tx_power, dir_rf, &il->disable_tx_power_cal);
1388         return 0;
1389
1390 err:
1391         IL_ERR("Can't create the debugfs directory\n");
1392         il_dbgfs_unregister(il);
1393         return -ENOMEM;
1394 }
1395 EXPORT_SYMBOL(il_dbgfs_register);
1396
1397 /**
1398  * Remove the debugfs files and directories
1399  *
1400  */
1401 void
1402 il_dbgfs_unregister(struct il_priv *il)
1403 {
1404         if (!il->debugfs_dir)
1405                 return;
1406
1407         debugfs_remove_recursive(il->debugfs_dir);
1408         il->debugfs_dir = NULL;
1409 }
1410 EXPORT_SYMBOL(il_dbgfs_unregister);