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