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