?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: tx/rx queue pointer information
[firewire-audio.git] / drivers / net / wireless / iwlwifi / iwl-debugfs.c
blobd4109cbb4f31fedd79bcbadfaf7a0f8a8ed498ac
1 /******************************************************************************
2 *
3 * GPL LICENSE SUMMARY
4 *
5 * Copyright(c) 2008 - 2009 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
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/debugfs.h>
32
33 #include <linux/ieee80211.h>
34 #include <net/mac80211.h>
35
36
37 #include "iwl-dev.h"
38 #include "iwl-debug.h"
39 #include "iwl-core.h"
40 #include "iwl-io.h"
41
42
43 /* create and remove of files */
44 #define DEBUGFS_ADD_DIR(name, parent) do { \
45 dbgfs->dir_##name = debugfs_create_dir(#name, parent); \
46 if (!(dbgfs->dir_##name)) \
47 goto err; \
48 } while (0)
49
50 #define DEBUGFS_ADD_FILE(name, parent) do { \
51 dbgfs->dbgfs_##parent##_files.file_##name = \
52 debugfs_create_file(#name, S_IWUSR | S_IRUSR, \
53 dbgfs->dir_##parent, priv, \
54 &iwl_dbgfs_##name##_ops); \
55 if (!(dbgfs->dbgfs_##parent##_files.file_##name)) \
56 goto err; \
57 } while (0)
58
59 #define DEBUGFS_ADD_BOOL(name, parent, ptr) do { \
60 dbgfs->dbgfs_##parent##_files.file_##name = \
61 debugfs_create_bool(#name, S_IWUSR | S_IRUSR, \
62 dbgfs->dir_##parent, ptr); \
63 if (IS_ERR(dbgfs->dbgfs_##parent##_files.file_##name) \
64 || !dbgfs->dbgfs_##parent##_files.file_##name) \
65 goto err; \
66 } while (0)
67
68 #define DEBUGFS_ADD_X32(name, parent, ptr) do { \
69 dbgfs->dbgfs_##parent##_files.file_##name = \
70 debugfs_create_x32(#name, S_IRUSR, dbgfs->dir_##parent, ptr); \
71 if (IS_ERR(dbgfs->dbgfs_##parent##_files.file_##name) \
72 || !dbgfs->dbgfs_##parent##_files.file_##name) \
73 goto err; \
74 } while (0)
75
76 #define DEBUGFS_REMOVE(name) do { \
77 debugfs_remove(name); \
78 name = NULL; \
79 } while (0);
80
81 /* file operation */
82 #define DEBUGFS_READ_FUNC(name) \
83 static ssize_t iwl_dbgfs_##name##_read(struct file *file, \
84 char __user *user_buf, \
85 size_t count, loff_t *ppos);
86
87 #define DEBUGFS_WRITE_FUNC(name) \
88 static ssize_t iwl_dbgfs_##name##_write(struct file *file, \
89 const char __user *user_buf, \
90 size_t count, loff_t *ppos);
91
92
93 static int iwl_dbgfs_open_file_generic(struct inode *inode, struct file *file)
94 {
95 file->private_data = inode->i_private;
96 return 0;
97 }
98
99 #define DEBUGFS_READ_FILE_OPS(name) \
100 DEBUGFS_READ_FUNC(name); \
101 static const struct file_operations iwl_dbgfs_##name##_ops = { \
102 .read = iwl_dbgfs_##name##_read, \
103 .open = iwl_dbgfs_open_file_generic, \
104 };
105
106 #define DEBUGFS_WRITE_FILE_OPS(name) \
107 DEBUGFS_WRITE_FUNC(name); \
108 static const struct file_operations iwl_dbgfs_##name##_ops = { \
109 .write = iwl_dbgfs_##name##_write, \
110 .open = iwl_dbgfs_open_file_generic, \
111 };
112
113
114 #define DEBUGFS_READ_WRITE_FILE_OPS(name) \
115 DEBUGFS_READ_FUNC(name); \
116 DEBUGFS_WRITE_FUNC(name); \
117 static const struct file_operations iwl_dbgfs_##name##_ops = { \
118 .write = iwl_dbgfs_##name##_write, \
119 .read = iwl_dbgfs_##name##_read, \
120 .open = iwl_dbgfs_open_file_generic, \
121 };
122
123
124 static ssize_t iwl_dbgfs_tx_statistics_read(struct file *file,
125 char __user *user_buf,
126 size_t count, loff_t *ppos) {
127
128 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
129 char *buf;
130 int pos = 0;
131
132 int cnt;
133 ssize_t ret;
134 const size_t bufsz = 100 + sizeof(char) * 24 * (MANAGEMENT_MAX + CONTROL_MAX);
135 buf = kzalloc(bufsz, GFP_KERNEL);
136 if (!buf)
137 return -ENOMEM;
138 pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
139 for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
140 pos += scnprintf(buf + pos, bufsz - pos,
141 "\t%s\t\t: %u\n",
142 get_mgmt_string(cnt),
143 priv->tx_stats.mgmt[cnt]);
144 }
145 pos += scnprintf(buf + pos, bufsz - pos, "Control\n");
146 for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
147 pos += scnprintf(buf + pos, bufsz - pos,
148 "\t%s\t\t: %u\n",
149 get_ctrl_string(cnt),
150 priv->tx_stats.ctrl[cnt]);
151 }
152 pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
153 pos += scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
154 priv->tx_stats.data_cnt);
155 pos += scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
156 priv->tx_stats.data_bytes);
157 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
158 kfree(buf);
159 return ret;
160 }
161
162 static ssize_t iwl_dbgfs_tx_statistics_write(struct file *file,
163 const char __user *user_buf,
164 size_t count, loff_t *ppos)
165 {
166 struct iwl_priv *priv = file->private_data;
167 u32 clear_flag;
168 char buf[8];
169 int buf_size;
170
171 memset(buf, 0, sizeof(buf));
172 buf_size = min(count, sizeof(buf) - 1);
173 if (copy_from_user(buf, user_buf, buf_size))
174 return -EFAULT;
175 if (sscanf(buf, "%x", &clear_flag) != 1)
176 return -EFAULT;
177 if (clear_flag == 1)
178 iwl_clear_tx_stats(priv);
179
180 return count;
181 }
182
183 static ssize_t iwl_dbgfs_rx_statistics_read(struct file *file,
184 char __user *user_buf,
185 size_t count, loff_t *ppos) {
186
187 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
188 char *buf;
189 int pos = 0;
190 int cnt;
191 ssize_t ret;
192 const size_t bufsz = 100 +
193 sizeof(char) * 24 * (MANAGEMENT_MAX + CONTROL_MAX);
194 buf = kzalloc(bufsz, GFP_KERNEL);
195 if (!buf)
196 return -ENOMEM;
197
198 pos += scnprintf(buf + pos, bufsz - pos, "Management:\n");
199 for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) {
200 pos += scnprintf(buf + pos, bufsz - pos,
201 "\t%s\t\t: %u\n",
202 get_mgmt_string(cnt),
203 priv->rx_stats.mgmt[cnt]);
204 }
205 pos += scnprintf(buf + pos, bufsz - pos, "Control:\n");
206 for (cnt = 0; cnt < CONTROL_MAX; cnt++) {
207 pos += scnprintf(buf + pos, bufsz - pos,
208 "\t%s\t\t: %u\n",
209 get_ctrl_string(cnt),
210 priv->rx_stats.ctrl[cnt]);
211 }
212 pos += scnprintf(buf + pos, bufsz - pos, "Data:\n");
213 pos += scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n",
214 priv->rx_stats.data_cnt);
215 pos += scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n",
216 priv->rx_stats.data_bytes);
217
218 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
219 kfree(buf);
220 return ret;
221 }
222
223 static ssize_t iwl_dbgfs_rx_statistics_write(struct file *file,
224 const char __user *user_buf,
225 size_t count, loff_t *ppos)
226 {
227 struct iwl_priv *priv = file->private_data;
228 u32 clear_flag;
229 char buf[8];
230 int buf_size;
231
232 memset(buf, 0, sizeof(buf));
233 buf_size = min(count, sizeof(buf) - 1);
234 if (copy_from_user(buf, user_buf, buf_size))
235 return -EFAULT;
236 if (sscanf(buf, "%x", &clear_flag) != 1)
237 return -EFAULT;
238 if (clear_flag == 1)
239 iwl_clear_rx_stats(priv);
240 return count;
241 }
242
243 #define BYTE1_MASK 0x000000ff;
244 #define BYTE2_MASK 0x0000ffff;
245 #define BYTE3_MASK 0x00ffffff;
246 static ssize_t iwl_dbgfs_sram_read(struct file *file,
247 char __user *user_buf,
248 size_t count, loff_t *ppos)
249 {
250 u32 val;
251 char buf[1024];
252 ssize_t ret;
253 int i;
254 int pos = 0;
255 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
256 const size_t bufsz = sizeof(buf);
257
258 for (i = priv->dbgfs->sram_len; i > 0; i -= 4) {
259 val = iwl_read_targ_mem(priv, priv->dbgfs->sram_offset + \
260 priv->dbgfs->sram_len - i);
261 if (i < 4) {
262 switch (i) {
263 case 1:
264 val &= BYTE1_MASK;
265 break;
266 case 2:
267 val &= BYTE2_MASK;
268 break;
269 case 3:
270 val &= BYTE3_MASK;
271 break;
272 }
273 }
274 pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val);
275 }
276 pos += scnprintf(buf + pos, bufsz - pos, "\n");
277
278 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
279 return ret;
280 }
281
282 static ssize_t iwl_dbgfs_sram_write(struct file *file,
283 const char __user *user_buf,
284 size_t count, loff_t *ppos)
285 {
286 struct iwl_priv *priv = file->private_data;
287 char buf[64];
288 int buf_size;
289 u32 offset, len;
290
291 memset(buf, 0, sizeof(buf));
292 buf_size = min(count, sizeof(buf) - 1);
293 if (copy_from_user(buf, user_buf, buf_size))
294 return -EFAULT;
295
296 if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
297 priv->dbgfs->sram_offset = offset;
298 priv->dbgfs->sram_len = len;
299 } else {
300 priv->dbgfs->sram_offset = 0;
301 priv->dbgfs->sram_len = 0;
302 }
303
304 return count;
305 }
306
307 static ssize_t iwl_dbgfs_stations_read(struct file *file, char __user *user_buf,
308 size_t count, loff_t *ppos)
309 {
310 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
311 struct iwl_station_entry *station;
312 int max_sta = priv->hw_params.max_stations;
313 char *buf;
314 int i, j, pos = 0;
315 ssize_t ret;
316 /* Add 30 for initial string */
317 const size_t bufsz = 30 + sizeof(char) * 500 * (priv->num_stations);
318
319 buf = kmalloc(bufsz, GFP_KERNEL);
320 if (!buf)
321 return -ENOMEM;
322
323 pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n",
324 priv->num_stations);
325
326 for (i = 0; i < max_sta; i++) {
327 station = &priv->stations[i];
328 if (station->used) {
329 pos += scnprintf(buf + pos, bufsz - pos,
330 "station %d:\ngeneral data:\n", i+1);
331 pos += scnprintf(buf + pos, bufsz - pos, "id: %u\n",
332 station->sta.sta.sta_id);
333 pos += scnprintf(buf + pos, bufsz - pos, "mode: %u\n",
334 station->sta.mode);
335 pos += scnprintf(buf + pos, bufsz - pos,
336 "flags: 0x%x\n",
337 station->sta.station_flags_msk);
338 pos += scnprintf(buf + pos, bufsz - pos,
339 "ps_status: %u\n", station->ps_status);
340 pos += scnprintf(buf + pos, bufsz - pos, "tid data:\n");
341 pos += scnprintf(buf + pos, bufsz - pos,
342 "seq_num\t\ttxq_id");
343 pos += scnprintf(buf + pos, bufsz - pos,
344 "\tframe_count\twait_for_ba\t");
345 pos += scnprintf(buf + pos, bufsz - pos,
346 "start_idx\tbitmap0\t");
347 pos += scnprintf(buf + pos, bufsz - pos,
348 "bitmap1\trate_n_flags");
349 pos += scnprintf(buf + pos, bufsz - pos, "\n");
350
351 for (j = 0; j < MAX_TID_COUNT; j++) {
352 pos += scnprintf(buf + pos, bufsz - pos,
353 "[%d]:\t\t%u", j,
354 station->tid[j].seq_number);
355 pos += scnprintf(buf + pos, bufsz - pos,
356 "\t%u\t\t%u\t\t%u\t\t",
357 station->tid[j].agg.txq_id,
358 station->tid[j].agg.frame_count,
359 station->tid[j].agg.wait_for_ba);
360 pos += scnprintf(buf + pos, bufsz - pos,
361 "%u\t%llu\t%u",
362 station->tid[j].agg.start_idx,
363 (unsigned long long)station->tid[j].agg.bitmap,
364 station->tid[j].agg.rate_n_flags);
365 pos += scnprintf(buf + pos, bufsz - pos, "\n");
366 }
367 pos += scnprintf(buf + pos, bufsz - pos, "\n");
368 }
369 }
370
371 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
372 kfree(buf);
373 return ret;
374 }
375
376 static ssize_t iwl_dbgfs_nvm_read(struct file *file,
377 char __user *user_buf,
378 size_t count,
379 loff_t *ppos)
380 {
381 ssize_t ret;
382 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
383 int pos = 0, ofs = 0, buf_size = 0;
384 const u8 *ptr;
385 char *buf;
386 size_t eeprom_len = priv->cfg->eeprom_size;
387 buf_size = 4 * eeprom_len + 256;
388
389 if (eeprom_len % 16) {
390 IWL_ERR(priv, "NVM size is not multiple of 16.\n");
391 return -ENODATA;
392 }
393
394 ptr = priv->eeprom;
395 if (!ptr) {
396 IWL_ERR(priv, "Invalid EEPROM/OTP memory\n");
397 return -ENOMEM;
398 }
399
400 /* 4 characters for byte 0xYY */
401 buf = kzalloc(buf_size, GFP_KERNEL);
402 if (!buf) {
403 IWL_ERR(priv, "Can not allocate Buffer\n");
404 return -ENOMEM;
405 }
406 pos += scnprintf(buf + pos, buf_size - pos, "NVM Type: %s\n",
407 (priv->nvm_device_type == NVM_DEVICE_TYPE_OTP)
408 ? "OTP" : "EEPROM");
409 for (ofs = 0 ; ofs < eeprom_len ; ofs += 16) {
410 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x ", ofs);
411 hex_dump_to_buffer(ptr + ofs, 16 , 16, 2, buf + pos,
412 buf_size - pos, 0);
413 pos += strlen(buf);
414 if (buf_size - pos > 0)
415 buf[pos++] = '\n';
416 }
417
418 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
419 kfree(buf);
420 return ret;
421 }
422
423 static ssize_t iwl_dbgfs_log_event_write(struct file *file,
424 const char __user *user_buf,
425 size_t count, loff_t *ppos)
426 {
427 struct iwl_priv *priv = file->private_data;
428 u32 event_log_flag;
429 char buf[8];
430 int buf_size;
431
432 memset(buf, 0, sizeof(buf));
433 buf_size = min(count, sizeof(buf) - 1);
434 if (copy_from_user(buf, user_buf, buf_size))
435 return -EFAULT;
436 if (sscanf(buf, "%d", &event_log_flag) != 1)
437 return -EFAULT;
438 if (event_log_flag == 1)
439 iwl_dump_nic_event_log(priv);
440
441 return count;
442 }
443
444
445
446 static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
447 size_t count, loff_t *ppos)
448 {
449 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
450 struct ieee80211_channel *channels = NULL;
451 const struct ieee80211_supported_band *supp_band = NULL;
452 int pos = 0, i, bufsz = PAGE_SIZE;
453 char *buf;
454 ssize_t ret;
455
456 if (!test_bit(STATUS_GEO_CONFIGURED, &priv->status))
457 return -EAGAIN;
458
459 buf = kzalloc(bufsz, GFP_KERNEL);
460 if (!buf) {
461 IWL_ERR(priv, "Can not allocate Buffer\n");
462 return -ENOMEM;
463 }
464
465 supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_2GHZ);
466 if (supp_band) {
467 channels = supp_band->channels;
468
469 pos += scnprintf(buf + pos, bufsz - pos,
470 "Displaying %d channels in 2.4GHz band 802.11bg):\n",
471 supp_band->n_channels);
472
473 for (i = 0; i < supp_band->n_channels; i++)
474 pos += scnprintf(buf + pos, bufsz - pos,
475 "%d: %ddBm: BSS%s%s, %s.\n",
476 ieee80211_frequency_to_channel(
477 channels[i].center_freq),
478 channels[i].max_power,
479 channels[i].flags & IEEE80211_CHAN_RADAR ?
480 " (IEEE 802.11h required)" : "",
481 ((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
482 || (channels[i].flags &
483 IEEE80211_CHAN_RADAR)) ? "" :
484 ", IBSS",
485 channels[i].flags &
486 IEEE80211_CHAN_PASSIVE_SCAN ?
487 "passive only" : "active/passive");
488 }
489 supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_5GHZ);
490 if (supp_band) {
491 channels = supp_band->channels;
492
493 pos += scnprintf(buf + pos, bufsz - pos,
494 "Displaying %d channels in 5.2GHz band (802.11a)\n",
495 supp_band->n_channels);
496
497 for (i = 0; i < supp_band->n_channels; i++)
498 pos += scnprintf(buf + pos, bufsz - pos,
499 "%d: %ddBm: BSS%s%s, %s.\n",
500 ieee80211_frequency_to_channel(
501 channels[i].center_freq),
502 channels[i].max_power,
503 channels[i].flags & IEEE80211_CHAN_RADAR ?
504 " (IEEE 802.11h required)" : "",
505 ((channels[i].flags & IEEE80211_CHAN_NO_IBSS)
506 || (channels[i].flags &
507 IEEE80211_CHAN_RADAR)) ? "" :
508 ", IBSS",
509 channels[i].flags &
510 IEEE80211_CHAN_PASSIVE_SCAN ?
511 "passive only" : "active/passive");
512 }
513 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
514 kfree(buf);
515 return ret;
516 }
517
518 static ssize_t iwl_dbgfs_status_read(struct file *file,
519 char __user *user_buf,
520 size_t count, loff_t *ppos) {
521
522 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
523 char buf[512];
524 int pos = 0;
525 const size_t bufsz = sizeof(buf);
526
527 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_HCMD_ACTIVE:\t %d\n",
528 test_bit(STATUS_HCMD_ACTIVE, &priv->status));
529 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_HCMD_SYNC_ACTIVE: %d\n",
530 test_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status));
531 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_INT_ENABLED:\t %d\n",
532 test_bit(STATUS_INT_ENABLED, &priv->status));
533 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_RF_KILL_HW:\t %d\n",
534 test_bit(STATUS_RF_KILL_HW, &priv->status));
535 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_INIT:\t\t %d\n",
536 test_bit(STATUS_INIT, &priv->status));
537 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_ALIVE:\t\t %d\n",
538 test_bit(STATUS_ALIVE, &priv->status));
539 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_READY:\t\t %d\n",
540 test_bit(STATUS_READY, &priv->status));
541 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_TEMPERATURE:\t %d\n",
542 test_bit(STATUS_TEMPERATURE, &priv->status));
543 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_GEO_CONFIGURED:\t %d\n",
544 test_bit(STATUS_GEO_CONFIGURED, &priv->status));
545 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_EXIT_PENDING:\t %d\n",
546 test_bit(STATUS_EXIT_PENDING, &priv->status));
547 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_STATISTICS:\t %d\n",
548 test_bit(STATUS_STATISTICS, &priv->status));
549 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCANNING:\t %d\n",
550 test_bit(STATUS_SCANNING, &priv->status));
551 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_ABORTING:\t %d\n",
552 test_bit(STATUS_SCAN_ABORTING, &priv->status));
553 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_SCAN_HW:\t\t %d\n",
554 test_bit(STATUS_SCAN_HW, &priv->status));
555 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_POWER_PMI:\t %d\n",
556 test_bit(STATUS_POWER_PMI, &priv->status));
557 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_FW_ERROR:\t %d\n",
558 test_bit(STATUS_FW_ERROR, &priv->status));
559 pos += scnprintf(buf + pos, bufsz - pos, "STATUS_MODE_PENDING:\t %d\n",
560 test_bit(STATUS_MODE_PENDING, &priv->status));
561 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
562 }
563
564 static ssize_t iwl_dbgfs_interrupt_read(struct file *file,
565 char __user *user_buf,
566 size_t count, loff_t *ppos) {
567
568 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
569 int pos = 0;
570 int cnt = 0;
571 char *buf;
572 int bufsz = 24 * 64; /* 24 items * 64 char per item */
573 ssize_t ret;
574
575 buf = kzalloc(bufsz, GFP_KERNEL);
576 if (!buf) {
577 IWL_ERR(priv, "Can not allocate Buffer\n");
578 return -ENOMEM;
579 }
580
581 pos += scnprintf(buf + pos, bufsz - pos,
582 "Interrupt Statistics Report:\n");
583
584 pos += scnprintf(buf + pos, bufsz - pos, "HW Error:\t\t\t %u\n",
585 priv->isr_stats.hw);
586 pos += scnprintf(buf + pos, bufsz - pos, "SW Error:\t\t\t %u\n",
587 priv->isr_stats.sw);
588 if (priv->isr_stats.sw > 0) {
589 pos += scnprintf(buf + pos, bufsz - pos,
590 "\tLast Restarting Code: 0x%X\n",
591 priv->isr_stats.sw_err);
592 }
593 #ifdef CONFIG_IWLWIFI_DEBUG
594 pos += scnprintf(buf + pos, bufsz - pos, "Frame transmitted:\t\t %u\n",
595 priv->isr_stats.sch);
596 pos += scnprintf(buf + pos, bufsz - pos, "Alive interrupt:\t\t %u\n",
597 priv->isr_stats.alive);
598 #endif
599 pos += scnprintf(buf + pos, bufsz - pos,
600 "HW RF KILL switch toggled:\t %u\n",
601 priv->isr_stats.rfkill);
602
603 pos += scnprintf(buf + pos, bufsz - pos, "CT KILL:\t\t\t %u\n",
604 priv->isr_stats.ctkill);
605
606 pos += scnprintf(buf + pos, bufsz - pos, "Wakeup Interrupt:\t\t %u\n",
607 priv->isr_stats.wakeup);
608
609 pos += scnprintf(buf + pos, bufsz - pos,
610 "Rx command responses:\t\t %u\n",
611 priv->isr_stats.rx);
612 for (cnt = 0; cnt < REPLY_MAX; cnt++) {
613 if (priv->isr_stats.rx_handlers[cnt] > 0)
614 pos += scnprintf(buf + pos, bufsz - pos,
615 "\tRx handler[%36s]:\t\t %u\n",
616 get_cmd_string(cnt),
617 priv->isr_stats.rx_handlers[cnt]);
618 }
619
620 pos += scnprintf(buf + pos, bufsz - pos, "Tx/FH interrupt:\t\t %u\n",
621 priv->isr_stats.tx);
622
623 pos += scnprintf(buf + pos, bufsz - pos, "Unexpected INTA:\t\t %u\n",
624 priv->isr_stats.unhandled);
625
626 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
627 kfree(buf);
628 return ret;
629 }
630
631 static ssize_t iwl_dbgfs_interrupt_write(struct file *file,
632 const char __user *user_buf,
633 size_t count, loff_t *ppos)
634 {
635 struct iwl_priv *priv = file->private_data;
636 char buf[8];
637 int buf_size;
638 u32 reset_flag;
639
640 memset(buf, 0, sizeof(buf));
641 buf_size = min(count, sizeof(buf) - 1);
642 if (copy_from_user(buf, user_buf, buf_size))
643 return -EFAULT;
644 if (sscanf(buf, "%x", &reset_flag) != 1)
645 return -EFAULT;
646 if (reset_flag == 0)
647 iwl_clear_isr_stats(priv);
648
649 return count;
650 }
651
652 static ssize_t iwl_dbgfs_qos_read(struct file *file, char __user *user_buf,
653 size_t count, loff_t *ppos)
654 {
655 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
656 int pos = 0, i;
657 char buf[256];
658 const size_t bufsz = sizeof(buf);
659 ssize_t ret;
660
661 for (i = 0; i < AC_NUM; i++) {
662 pos += scnprintf(buf + pos, bufsz - pos,
663 "\tcw_min\tcw_max\taifsn\ttxop\n");
664 pos += scnprintf(buf + pos, bufsz - pos,
665 "AC[%d]\t%u\t%u\t%u\t%u\n", i,
666 priv->qos_data.def_qos_parm.ac[i].cw_min,
667 priv->qos_data.def_qos_parm.ac[i].cw_max,
668 priv->qos_data.def_qos_parm.ac[i].aifsn,
669 priv->qos_data.def_qos_parm.ac[i].edca_txop);
670 }
671 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
672 return ret;
673 }
674
675 #ifdef CONFIG_IWLWIFI_LEDS
676 static ssize_t iwl_dbgfs_led_read(struct file *file, char __user *user_buf,
677 size_t count, loff_t *ppos)
678 {
679 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
680 int pos = 0;
681 char buf[256];
682 const size_t bufsz = sizeof(buf);
683 ssize_t ret;
684
685 pos += scnprintf(buf + pos, bufsz - pos,
686 "allow blinking: %s\n",
687 (priv->allow_blinking) ? "True" : "False");
688 if (priv->allow_blinking) {
689 pos += scnprintf(buf + pos, bufsz - pos,
690 "Led blinking rate: %u\n",
691 priv->last_blink_rate);
692 pos += scnprintf(buf + pos, bufsz - pos,
693 "Last blink time: %lu\n",
694 priv->last_blink_time);
695 }
696
697 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
698 return ret;
699 }
700 #endif
701
702 static ssize_t iwl_dbgfs_thermal_throttling_read(struct file *file,
703 char __user *user_buf,
704 size_t count, loff_t *ppos)
705 {
706 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
707 struct iwl_tt_mgmt *tt = &priv->power_data.tt;
708 struct iwl_tt_restriction *restriction;
709 char buf[100];
710 int pos = 0;
711 const size_t bufsz = sizeof(buf);
712 ssize_t ret;
713
714 pos += scnprintf(buf + pos, bufsz - pos,
715 "Thermal Throttling Mode: %s\n",
716 (priv->power_data.adv_tt)
717 ? "Advance" : "Legacy");
718 pos += scnprintf(buf + pos, bufsz - pos,
719 "Thermal Throttling State: %d\n",
720 tt->state);
721 if (priv->power_data.adv_tt) {
722 restriction = tt->restriction + tt->state;
723 pos += scnprintf(buf + pos, bufsz - pos,
724 "Tx mode: %d\n",
725 restriction->tx_stream);
726 pos += scnprintf(buf + pos, bufsz - pos,
727 "Rx mode: %d\n",
728 restriction->rx_stream);
729 pos += scnprintf(buf + pos, bufsz - pos,
730 "HT mode: %d\n",
731 restriction->is_ht);
732 }
733 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
734 return ret;
735 }
736
737 static ssize_t iwl_dbgfs_disable_ht40_write(struct file *file,
738 const char __user *user_buf,
739 size_t count, loff_t *ppos)
740 {
741 struct iwl_priv *priv = file->private_data;
742 char buf[8];
743 int buf_size;
744 int ht40;
745
746 memset(buf, 0, sizeof(buf));
747 buf_size = min(count, sizeof(buf) - 1);
748 if (copy_from_user(buf, user_buf, buf_size))
749 return -EFAULT;
750 if (sscanf(buf, "%d", &ht40) != 1)
751 return -EFAULT;
752 if (!iwl_is_associated(priv))
753 priv->disable_ht40 = ht40 ? true : false;
754 else {
755 IWL_ERR(priv, "Sta associated with AP - "
756 "Change to 40MHz channel support is not allowed\n");
757 return -EINVAL;
758 }
759
760 return count;
761 }
762
763 static ssize_t iwl_dbgfs_disable_ht40_read(struct file *file,
764 char __user *user_buf,
765 size_t count, loff_t *ppos)
766 {
767 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
768 char buf[100];
769 int pos = 0;
770 const size_t bufsz = sizeof(buf);
771 ssize_t ret;
772
773 pos += scnprintf(buf + pos, bufsz - pos,
774 "11n 40MHz Mode: %s\n",
775 priv->disable_ht40 ? "Disabled" : "Enabled");
776 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
777 return ret;
778 }
779
780 DEBUGFS_READ_WRITE_FILE_OPS(sram);
781 DEBUGFS_WRITE_FILE_OPS(log_event);
782 DEBUGFS_READ_FILE_OPS(nvm);
783 DEBUGFS_READ_FILE_OPS(stations);
784 DEBUGFS_READ_FILE_OPS(channels);
785 DEBUGFS_READ_FILE_OPS(status);
786 DEBUGFS_READ_WRITE_FILE_OPS(interrupt);
787 DEBUGFS_READ_FILE_OPS(qos);
788 #ifdef CONFIG_IWLWIFI_LEDS
789 DEBUGFS_READ_FILE_OPS(led);
790 #endif
791 DEBUGFS_READ_FILE_OPS(thermal_throttling);
792 DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40);
793
794 static ssize_t iwl_dbgfs_traffic_log_read(struct file *file,
795 char __user *user_buf,
796 size_t count, loff_t *ppos)
797 {
798 struct iwl_priv *priv = file->private_data;
799 int pos = 0, ofs = 0;
800 int cnt = 0, entry;
801 struct iwl_tx_queue *txq;
802 struct iwl_queue *q;
803 struct iwl_rx_queue *rxq = &priv->rxq;
804 char *buf;
805 int bufsz = ((IWL_TRAFFIC_ENTRIES * IWL_TRAFFIC_ENTRY_SIZE * 64) * 2) +
806 (IWL_MAX_NUM_QUEUES * 32 * 8) + 400;
807 const u8 *ptr;
808 ssize_t ret;
809
810 buf = kzalloc(bufsz, GFP_KERNEL);
811 if (!buf) {
812 IWL_ERR(priv, "Can not allocate buffer\n");
813 return -ENOMEM;
814 }
815 pos += scnprintf(buf + pos, bufsz - pos, "Tx Queue\n");
816 for (cnt = 0; cnt < priv->hw_params.max_txq_num; cnt++) {
817 txq = &priv->txq[cnt];
818 q = &txq->q;
819 pos += scnprintf(buf + pos, bufsz - pos,
820 "q[%d]: read_ptr: %u, write_ptr: %u\n",
821 cnt, q->read_ptr, q->write_ptr);
822 }
823 if (priv->tx_traffic && (iwl_debug_level & IWL_DL_TX)) {
824 ptr = priv->tx_traffic;
825 pos += scnprintf(buf + pos, bufsz - pos,
826 "Tx Traffic idx: %u\n", priv->tx_traffic_idx);
827 for (cnt = 0, ofs = 0; cnt < IWL_TRAFFIC_ENTRIES; cnt++) {
828 for (entry = 0; entry < IWL_TRAFFIC_ENTRY_SIZE / 16;
829 entry++, ofs += 16) {
830 pos += scnprintf(buf + pos, bufsz - pos,
831 "0x%.4x ", ofs);
832 hex_dump_to_buffer(ptr + ofs, 16, 16, 2,
833 buf + pos, bufsz - pos, 0);
834 pos += strlen(buf);
835 if (bufsz - pos > 0)
836 buf[pos++] = '\n';
837 }
838 }
839 }
840
841 pos += scnprintf(buf + pos, bufsz - pos, "Rx Queue\n");
842 pos += scnprintf(buf + pos, bufsz - pos,
843 "read: %u, write: %u\n",
844 rxq->read, rxq->write);
845
846 if (priv->rx_traffic && (iwl_debug_level & IWL_DL_RX)) {
847 ptr = priv->rx_traffic;
848 pos += scnprintf(buf + pos, bufsz - pos,
849 "Rx Traffic idx: %u\n", priv->rx_traffic_idx);
850 for (cnt = 0, ofs = 0; cnt < IWL_TRAFFIC_ENTRIES; cnt++) {
851 for (entry = 0; entry < IWL_TRAFFIC_ENTRY_SIZE / 16;
852 entry++, ofs += 16) {
853 pos += scnprintf(buf + pos, bufsz - pos,
854 "0x%.4x ", ofs);
855 hex_dump_to_buffer(ptr + ofs, 16, 16, 2,
856 buf + pos, bufsz - pos, 0);
857 pos += strlen(buf);
858 if (bufsz - pos > 0)
859 buf[pos++] = '\n';
860 }
861 }
862 }
863
864 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
865 kfree(buf);
866 return ret;
867 }
868
869 static ssize_t iwl_dbgfs_traffic_log_write(struct file *file,
870 const char __user *user_buf,
871 size_t count, loff_t *ppos)
872 {
873 struct iwl_priv *priv = file->private_data;
874 char buf[8];
875 int buf_size;
876 int traffic_log;
877
878 memset(buf, 0, sizeof(buf));
879 buf_size = min(count, sizeof(buf) - 1);
880 if (copy_from_user(buf, user_buf, buf_size))
881 return -EFAULT;
882 if (sscanf(buf, "%d", &traffic_log) != 1)
883 return -EFAULT;
884 if (traffic_log == 0)
885 iwl_reset_traffic_log(priv);
886
887 return count;
888 }
889
890 static ssize_t iwl_dbgfs_tx_queue_read(struct file *file,
891 char __user *user_buf,
892 size_t count, loff_t *ppos) {
893
894 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
895 struct iwl_tx_queue *txq;
896 struct iwl_queue *q;
897 char *buf;
898 int pos = 0;
899 int cnt;
900 int ret;
901 const size_t bufsz = sizeof(char) * 60 * IWL_MAX_NUM_QUEUES;
902
903 buf = kzalloc(bufsz, GFP_KERNEL);
904 if (!buf)
905 return -ENOMEM;
906
907 for (cnt = 0; cnt < priv->hw_params.max_txq_num; cnt++) {
908 txq = &priv->txq[cnt];
909 q = &txq->q;
910 pos += scnprintf(buf + pos, bufsz - pos,
911 "hwq %.2d: read=%u write=%u stop=%d"
912 " swq_id=%#.2x (ac %d/hwq %d)\n",
913 cnt, q->read_ptr, q->write_ptr,
914 !!test_bit(cnt, priv->queue_stopped),
915 txq->swq_id,
916 txq->swq_id & 0x80 ? txq->swq_id & 3 :
917 txq->swq_id,
918 txq->swq_id & 0x80 ? (txq->swq_id >> 2) &
919 0x1f : txq->swq_id);
920 if (cnt >= 4)
921 continue;
922 /* for the ACs, display the stop count too */
923 pos += scnprintf(buf + pos, bufsz - pos,
924 " stop-count: %d\n",
925 atomic_read(&priv->queue_stop_count[cnt]));
926 }
927 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
928 kfree(buf);
929 return ret;
930 }
931
932 static ssize_t iwl_dbgfs_rx_queue_read(struct file *file,
933 char __user *user_buf,
934 size_t count, loff_t *ppos) {
935
936 struct iwl_priv *priv = (struct iwl_priv *)file->private_data;
937 struct iwl_rx_queue *rxq = &priv->rxq;
938 char buf[256];
939 int pos = 0;
940 const size_t bufsz = sizeof(buf);
941
942 pos += scnprintf(buf + pos, bufsz - pos, "read: %u\n",
943 rxq->read);
944 pos += scnprintf(buf + pos, bufsz - pos, "write: %u\n",
945 rxq->write);
946 pos += scnprintf(buf + pos, bufsz - pos, "free_count: %u\n",
947 rxq->free_count);
948 pos += scnprintf(buf + pos, bufsz - pos, "closed_rb_num: %u\n",
949 le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF);
950 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
951 }
952
953 DEBUGFS_READ_WRITE_FILE_OPS(rx_statistics);
954 DEBUGFS_READ_WRITE_FILE_OPS(tx_statistics);
955 DEBUGFS_READ_WRITE_FILE_OPS(traffic_log);
956 DEBUGFS_READ_FILE_OPS(rx_queue);
957 DEBUGFS_READ_FILE_OPS(tx_queue);
958
959 /*
960 * Create the debugfs files and directories
961 *
962 */
963 int iwl_dbgfs_register(struct iwl_priv *priv, const char *name)
964 {
965 struct iwl_debugfs *dbgfs;
966 struct dentry *phyd = priv->hw->wiphy->debugfsdir;
967 int ret = 0;
968
969 dbgfs = kzalloc(sizeof(struct iwl_debugfs), GFP_KERNEL);
970 if (!dbgfs) {
971 ret = -ENOMEM;
972 goto err;
973 }
974
975 priv->dbgfs = dbgfs;
976 dbgfs->name = name;
977 dbgfs->dir_drv = debugfs_create_dir(name, phyd);
978 if (!dbgfs->dir_drv || IS_ERR(dbgfs->dir_drv)) {
979 ret = -ENOENT;
980 goto err;
981 }
982
983 DEBUGFS_ADD_DIR(data, dbgfs->dir_drv);
984 DEBUGFS_ADD_DIR(rf, dbgfs->dir_drv);
985 DEBUGFS_ADD_DIR(debug, dbgfs->dir_drv);
986 DEBUGFS_ADD_FILE(nvm, data);
987 DEBUGFS_ADD_FILE(sram, data);
988 DEBUGFS_ADD_FILE(log_event, data);
989 DEBUGFS_ADD_FILE(stations, data);
990 DEBUGFS_ADD_FILE(channels, data);
991 DEBUGFS_ADD_FILE(status, data);
992 DEBUGFS_ADD_FILE(interrupt, data);
993 DEBUGFS_ADD_FILE(qos, data);
994 #ifdef CONFIG_IWLWIFI_LEDS
995 DEBUGFS_ADD_FILE(led, data);
996 #endif
997 DEBUGFS_ADD_FILE(thermal_throttling, data);
998 DEBUGFS_ADD_FILE(disable_ht40, data);
999 DEBUGFS_ADD_FILE(rx_statistics, debug);
1000 DEBUGFS_ADD_FILE(tx_statistics, debug);
1001 DEBUGFS_ADD_FILE(traffic_log, debug);
1002 DEBUGFS_ADD_FILE(rx_queue, debug);
1003 DEBUGFS_ADD_FILE(tx_queue, debug);
1004 DEBUGFS_ADD_BOOL(disable_sensitivity, rf, &priv->disable_sens_cal);
1005 DEBUGFS_ADD_BOOL(disable_chain_noise, rf,
1006 &priv->disable_chain_noise_cal);
1007 if (((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_4965) ||
1008 ((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_3945))
1009 DEBUGFS_ADD_BOOL(disable_tx_power, rf,
1010 &priv->disable_tx_power_cal);
1011 return 0;
1012
1013 err:
1014 IWL_ERR(priv, "Can't open the debugfs directory\n");
1015 iwl_dbgfs_unregister(priv);
1016 return ret;
1017 }
1018 EXPORT_SYMBOL(iwl_dbgfs_register);
1019
1020 /**
1021 * Remove the debugfs files and directories
1022 *
1023 */
1024 void iwl_dbgfs_unregister(struct iwl_priv *priv)
1025 {
1026 if (!priv->dbgfs)
1027 return;
1028
1029 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_nvm);
1030 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_sram);
1031 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_log_event);
1032 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_stations);
1033 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_channels);
1034 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_status);
1035 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_interrupt);
1036 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_qos);
1037 #ifdef CONFIG_IWLWIFI_LEDS
1038 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_led);
1039 #endif
1040 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_thermal_throttling);
1041 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_data_files.file_disable_ht40);
1042 DEBUGFS_REMOVE(priv->dbgfs->dir_data);
1043 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_debug_files.file_rx_statistics);
1044 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_debug_files.file_tx_statistics);
1045 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_debug_files.file_traffic_log);
1046 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_debug_files.file_rx_queue);
1047 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_debug_files.file_tx_queue);
1048 DEBUGFS_REMOVE(priv->dbgfs->dir_debug);
1049 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_sensitivity);
1050 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_chain_noise);
1051 if (((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_4965) ||
1052 ((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_3945))
1053 DEBUGFS_REMOVE(priv->dbgfs->dbgfs_rf_files.file_disable_tx_power);
1054 DEBUGFS_REMOVE(priv->dbgfs->dir_rf);
1055 DEBUGFS_REMOVE(priv->dbgfs->dir_drv);
1056 kfree(priv->dbgfs);
1057 priv->dbgfs = NULL;
1058 }
1059 EXPORT_SYMBOL(iwl_dbgfs_unregister);
1060
1061
1062
AMDTP streaming driver for the Linux FireWire stack (Juju)