projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: Set different wake up conditions in case of suspend
[linux-2.6-block.git] / drivers / net / wireless / wl12xx / debugfs.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
4 * Copyright (C) 2009 Nokia Corporation
5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 */
23
00d20100 24#include "debugfs.h"
f5fc0f86
LC		 25
26#include <linux/skbuff.h>
5a0e3ad6 27#include <linux/slab.h>
f5fc0f86 28
00d20100 29#include "wl12xx.h"
0f4e3122 30#include "debug.h"
00d20100
SL		 31#include "acx.h"
32#include "ps.h"
33#include "io.h"
f1a46384 34#include "tx.h"
f5fc0f86
LC		 35
36/* ms */
37#define WL1271_DEBUGFS_STATS_LIFETIME 1000
38
39/* debugfs macros idea from mac80211 */
03107a4b
EP		 40#define DEBUGFS_FORMAT_BUFFER_SIZE 100
41static int wl1271_format_buffer(char __user *userbuf, size_t count,
42 loff_t *ppos, char *fmt, ...)
43{
44 va_list args;
45 char buf[DEBUGFS_FORMAT_BUFFER_SIZE];
46 int res;
47
48 va_start(args, fmt);
49 res = vscnprintf(buf, sizeof(buf), fmt, args);
50 va_end(args);
f5fc0f86 51
03107a4b
EP		 52 return simple_read_from_buffer(userbuf, count, ppos, buf, res);
53}
54
55#define DEBUGFS_READONLY_FILE(name, fmt, value...) \
f5fc0f86
LC		 56static ssize_t name## _read(struct file *file, char __user *userbuf, \
57 size_t count, loff_t *ppos) \
58{ \
59 struct wl1271 *wl = file->private_data; \
03107a4b
EP		 60 return wl1271_format_buffer(userbuf, count, ppos, \
61 fmt "\n", ##value); \
f5fc0f86
LC		 62} \
63 \
64static const struct file_operations name## _ops = { \
65 .read = name## _read, \
66 .open = wl1271_open_file_generic, \
2b18ab36 67 .llseek = generic_file_llseek, \
f5fc0f86
LC		 68};
69
70#define DEBUGFS_ADD(name, parent) \
7cb2cea9
EP		 71 entry = debugfs_create_file(#name, 0400, parent, \
72 wl, &name## _ops); \
73 if (!entry || IS_ERR(entry)) \
74 goto err; \
f5fc0f86 75
c84368e0
EP		 76#define DEBUGFS_ADD_PREFIX(prefix, name, parent) \
77 do { \
78 entry = debugfs_create_file(#name, 0400, parent, \
79 wl, &prefix## _## name## _ops); \
80 if (!entry || IS_ERR(entry)) \
81 goto err; \
82 } while (0);
83
03107a4b 84#define DEBUGFS_FWSTATS_FILE(sub, name, fmt) \
f5fc0f86
LC		 85static ssize_t sub## _ ##name## _read(struct file *file, \
86 char __user *userbuf, \
87 size_t count, loff_t *ppos) \
88{ \
89 struct wl1271 *wl = file->private_data; \
f5fc0f86
LC		 90 \
91 wl1271_debugfs_update_stats(wl); \
92 \
03107a4b
EP		 93 return wl1271_format_buffer(userbuf, count, ppos, fmt "\n", \
94 wl->stats.fw_stats->sub.name); \
f5fc0f86
LC		 95} \
96 \
97static const struct file_operations sub## _ ##name## _ops = { \
98 .read = sub## _ ##name## _read, \
99 .open = wl1271_open_file_generic, \
2b18ab36 100 .llseek = generic_file_llseek, \
f5fc0f86
LC		 101};
102
103#define DEBUGFS_FWSTATS_ADD(sub, name) \
7cb2cea9 104 DEBUGFS_ADD(sub## _ ##name, stats)
f5fc0f86
LC		 105
106static void wl1271_debugfs_update_stats(struct wl1271 *wl)
107{
108 int ret;
109
110 mutex_lock(&wl->mutex);
111
a620865e 112 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 113 if (ret < 0)
114 goto out;
115
116 if (wl->state == WL1271_STATE_ON &&
117 time_after(jiffies, wl->stats.fw_stats_update +
118 msecs_to_jiffies(WL1271_DEBUGFS_STATS_LIFETIME))) {
119 wl1271_acx_statistics(wl, wl->stats.fw_stats);
120 wl->stats.fw_stats_update = jiffies;
121 }
122
123 wl1271_ps_elp_sleep(wl);
124
125out:
126 mutex_unlock(&wl->mutex);
127}
128
129static int wl1271_open_file_generic(struct inode *inode, struct file *file)
130{
131 file->private_data = inode->i_private;
132 return 0;
133}
134
03107a4b
EP		 135DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, "%u");
136
137DEBUGFS_FWSTATS_FILE(rx, out_of_mem, "%u");
138DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, "%u");
139DEBUGFS_FWSTATS_FILE(rx, hw_stuck, "%u");
140DEBUGFS_FWSTATS_FILE(rx, dropped, "%u");
141DEBUGFS_FWSTATS_FILE(rx, fcs_err, "%u");
142DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, "%u");
143DEBUGFS_FWSTATS_FILE(rx, path_reset, "%u");
144DEBUGFS_FWSTATS_FILE(rx, reset_counter, "%u");
145
146DEBUGFS_FWSTATS_FILE(dma, rx_requested, "%u");
147DEBUGFS_FWSTATS_FILE(dma, rx_errors, "%u");
148DEBUGFS_FWSTATS_FILE(dma, tx_requested, "%u");
149DEBUGFS_FWSTATS_FILE(dma, tx_errors, "%u");
150
151DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, "%u");
152DEBUGFS_FWSTATS_FILE(isr, fiqs, "%u");
153DEBUGFS_FWSTATS_FILE(isr, rx_headers, "%u");
154DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, "%u");
155DEBUGFS_FWSTATS_FILE(isr, rx_rdys, "%u");
156DEBUGFS_FWSTATS_FILE(isr, irqs, "%u");
157DEBUGFS_FWSTATS_FILE(isr, tx_procs, "%u");
158DEBUGFS_FWSTATS_FILE(isr, decrypt_done, "%u");
159DEBUGFS_FWSTATS_FILE(isr, dma0_done, "%u");
160DEBUGFS_FWSTATS_FILE(isr, dma1_done, "%u");
161DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, "%u");
162DEBUGFS_FWSTATS_FILE(isr, commands, "%u");
163DEBUGFS_FWSTATS_FILE(isr, rx_procs, "%u");
164DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, "%u");
165DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, "%u");
166DEBUGFS_FWSTATS_FILE(isr, pci_pm, "%u");
167DEBUGFS_FWSTATS_FILE(isr, wakeups, "%u");
168DEBUGFS_FWSTATS_FILE(isr, low_rssi, "%u");
169
170DEBUGFS_FWSTATS_FILE(wep, addr_key_count, "%u");
171DEBUGFS_FWSTATS_FILE(wep, default_key_count, "%u");
f5fc0f86 172/* skipping wep.reserved */
03107a4b
EP		 173DEBUGFS_FWSTATS_FILE(wep, key_not_found, "%u");
174DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, "%u");
175DEBUGFS_FWSTATS_FILE(wep, packets, "%u");
176DEBUGFS_FWSTATS_FILE(wep, interrupt, "%u");
177
178DEBUGFS_FWSTATS_FILE(pwr, ps_enter, "%u");
179DEBUGFS_FWSTATS_FILE(pwr, elp_enter, "%u");
180DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, "%u");
181DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, "%u");
182DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, "%u");
183DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, "%u");
184DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, "%u");
185DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, "%u");
186DEBUGFS_FWSTATS_FILE(pwr, power_save_off, "%u");
187DEBUGFS_FWSTATS_FILE(pwr, enable_ps, "%u");
188DEBUGFS_FWSTATS_FILE(pwr, disable_ps, "%u");
189DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, "%u");
f5fc0f86 190/* skipping cont_miss_bcns_spread for now */
03107a4b
EP		 191DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, "%u");
192
193DEBUGFS_FWSTATS_FILE(mic, rx_pkts, "%u");
194DEBUGFS_FWSTATS_FILE(mic, calc_failure, "%u");
195
196DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, "%u");
197DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, "%u");
198DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, "%u");
199DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, "%u");
200DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, "%u");
201DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, "%u");
202
203DEBUGFS_FWSTATS_FILE(event, heart_beat, "%u");
204DEBUGFS_FWSTATS_FILE(event, calibration, "%u");
205DEBUGFS_FWSTATS_FILE(event, rx_mismatch, "%u");
206DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, "%u");
207DEBUGFS_FWSTATS_FILE(event, rx_pool, "%u");
208DEBUGFS_FWSTATS_FILE(event, oom_late, "%u");
209DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, "%u");
210DEBUGFS_FWSTATS_FILE(event, tx_stuck, "%u");
211
212DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, "%u");
213DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, "%u");
214DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, "%u");
215DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, "%u");
216DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, "%u");
217DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, "%u");
218DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, "%u");
219
220DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, "%u");
221DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, "%u");
222DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data, "%u");
223DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, "%u");
224DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, "%u");
225
226DEBUGFS_READONLY_FILE(retry_count, "%u", wl->stats.retry_count);
227DEBUGFS_READONLY_FILE(excessive_retries, "%u",
f5fc0f86
LC		 228 wl->stats.excessive_retries);
229
230static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
231 size_t count, loff_t *ppos)
232{
233 struct wl1271 *wl = file->private_data;
234 u32 queue_len;
235 char buf[20];
236 int res;
237
f1a46384 238 queue_len = wl1271_tx_total_queue_count(wl);
f5fc0f86
LC		 239
240 res = scnprintf(buf, sizeof(buf), "%u\n", queue_len);
241 return simple_read_from_buffer(userbuf, count, ppos, buf, res);
242}
243
244static const struct file_operations tx_queue_len_ops = {
245 .read = tx_queue_len_read,
246 .open = wl1271_open_file_generic,
6038f373 247 .llseek = default_llseek,
f5fc0f86
LC		 248};
249
98b2a684
LC		 250static ssize_t gpio_power_read(struct file *file, char __user *user_buf,
251 size_t count, loff_t *ppos)
252{
253 struct wl1271 *wl = file->private_data;
71449f8d
JO		 254 bool state = test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
255
98b2a684
LC		 256 int res;
257 char buf[10];
258
71449f8d 259 res = scnprintf(buf, sizeof(buf), "%d\n", state);
98b2a684
LC		 260
261 return simple_read_from_buffer(user_buf, count, ppos, buf, res);
262}
263
264static ssize_t gpio_power_write(struct file *file,
265 const char __user *user_buf,
266 size_t count, loff_t *ppos)
267{
268 struct wl1271 *wl = file->private_data;
98b2a684
LC		 269 unsigned long value;
270 int ret;
271
b6883582 272 ret = kstrtoul_from_user(user_buf, count, 10, &value);
98b2a684
LC		 273 if (ret < 0) {
274 wl1271_warning("illegal value in gpio_power");
8e2de74e 275 return -EINVAL;
98b2a684
LC		 276 }
277
8e2de74e
EP		 278 mutex_lock(&wl->mutex);
279
becd551c
TP		 280 if (value)
281 wl1271_power_on(wl);
282 else
283 wl1271_power_off(wl);
98b2a684 284
98b2a684
LC		 285 mutex_unlock(&wl->mutex);
286 return count;
287}
288
289static const struct file_operations gpio_power_ops = {
290 .read = gpio_power_read,
291 .write = gpio_power_write,
6038f373
AB		 292 .open = wl1271_open_file_generic,
293 .llseek = default_llseek,
98b2a684
LC		 294};
295
2dc5a5c2
AN		 296static ssize_t start_recovery_write(struct file *file,
297 const char __user *user_buf,
298 size_t count, loff_t *ppos)
299{
300 struct wl1271 *wl = file->private_data;
301
302 mutex_lock(&wl->mutex);
baacb9ae 303 wl12xx_queue_recovery_work(wl);
2dc5a5c2
AN		 304 mutex_unlock(&wl->mutex);
305
306 return count;
307}
308
309static const struct file_operations start_recovery_ops = {
310 .write = start_recovery_write,
311 .open = wl1271_open_file_generic,
312 .llseek = default_llseek,
313};
314
1faff895
ES		 315static ssize_t dynamic_ps_timeout_read(struct file *file, char __user *user_buf,
316 size_t count, loff_t *ppos)
317{
318 struct wl1271 *wl = file->private_data;
319
320 return wl1271_format_buffer(user_buf, count,
321 ppos, "%d\n",
322 wl->conf.conn.dynamic_ps_timeout);
323}
324
325static ssize_t dynamic_ps_timeout_write(struct file *file,
326 const char __user *user_buf,
327 size_t count, loff_t *ppos)
328{
329 struct wl1271 *wl = file->private_data;
330 struct wl12xx_vif *wlvif;
331 unsigned long value;
332 int ret;
333
334 ret = kstrtoul_from_user(user_buf, count, 10, &value);
335 if (ret < 0) {
336 wl1271_warning("illegal value in dynamic_ps");
337 return -EINVAL;
338 }
339
340 if (value < 1 || value > 65535) {
341 wl1271_warning("dyanmic_ps_timeout is not in valid range");
342 return -ERANGE;
343 }
344
345 mutex_lock(&wl->mutex);
346
347 wl->conf.conn.dynamic_ps_timeout = value;
348
349 if (wl->state == WL1271_STATE_OFF)
350 goto out;
351
352 ret = wl1271_ps_elp_wakeup(wl);
353 if (ret < 0)
354 goto out;
355
356 /* In case we're already in PSM, trigger it again to set new timeout
357 * immediately without waiting for re-association
358 */
359
360 wl12xx_for_each_wlvif_sta(wl, wlvif) {
d18da7fc 361 if (test_bit(WLVIF_FLAG_IN_AUTO_PS, &wlvif->flags))
248a0018 362 wl1271_ps_set_mode(wl, wlvif, STATION_AUTO_PS_MODE);
1faff895
ES		 363 }
364
365 wl1271_ps_elp_sleep(wl);
366
367out:
368 mutex_unlock(&wl->mutex);
369 return count;
370}
371
372static const struct file_operations dynamic_ps_timeout_ops = {
373 .read = dynamic_ps_timeout_read,
374 .write = dynamic_ps_timeout_write,
375 .open = wl1271_open_file_generic,
376 .llseek = default_llseek,
377};
378
2d66bee7
AN		 379static ssize_t driver_state_read(struct file *file, char __user *user_buf,
380 size_t count, loff_t *ppos)
381{
382 struct wl1271 *wl = file->private_data;
383 int res = 0;
c99f895a
LC		 384 ssize_t ret;
385 char *buf;
386
387#define DRIVER_STATE_BUF_LEN 1024
388
389 buf = kmalloc(DRIVER_STATE_BUF_LEN, GFP_KERNEL);
390 if (!buf)
391 return -ENOMEM;
2d66bee7
AN		 392
393 mutex_lock(&wl->mutex);
394
395#define DRIVER_STATE_PRINT(x, fmt) \
c99f895a 396 (res += scnprintf(buf + res, DRIVER_STATE_BUF_LEN - res,\
2d66bee7
AN		 397 #x " = " fmt "\n", wl->x))
398
399#define DRIVER_STATE_PRINT_LONG(x) DRIVER_STATE_PRINT(x, "%ld")
400#define DRIVER_STATE_PRINT_INT(x) DRIVER_STATE_PRINT(x, "%d")
401#define DRIVER_STATE_PRINT_STR(x) DRIVER_STATE_PRINT(x, "%s")
402#define DRIVER_STATE_PRINT_LHEX(x) DRIVER_STATE_PRINT(x, "0x%lx")
403#define DRIVER_STATE_PRINT_HEX(x) DRIVER_STATE_PRINT(x, "0x%x")
404
405 DRIVER_STATE_PRINT_INT(tx_blocks_available);
7bb5d6ce 406 DRIVER_STATE_PRINT_INT(tx_allocated_blocks);
742246f8
AN		 407 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[0]);
408 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[1]);
409 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[2]);
410 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[3]);
2d66bee7
AN		 411 DRIVER_STATE_PRINT_INT(tx_frames_cnt);
412 DRIVER_STATE_PRINT_LHEX(tx_frames_map[0]);
f1a46384
AN		 413 DRIVER_STATE_PRINT_INT(tx_queue_count[0]);
414 DRIVER_STATE_PRINT_INT(tx_queue_count[1]);
415 DRIVER_STATE_PRINT_INT(tx_queue_count[2]);
416 DRIVER_STATE_PRINT_INT(tx_queue_count[3]);
2d66bee7
AN		 417 DRIVER_STATE_PRINT_INT(tx_packets_count);
418 DRIVER_STATE_PRINT_INT(tx_results_count);
419 DRIVER_STATE_PRINT_LHEX(flags);
4d56ad9c 420 DRIVER_STATE_PRINT_INT(tx_blocks_freed);
2d66bee7 421 DRIVER_STATE_PRINT_INT(rx_counter);
2d66bee7 422 DRIVER_STATE_PRINT_INT(state);
2d66bee7 423 DRIVER_STATE_PRINT_INT(channel);
2d66bee7 424 DRIVER_STATE_PRINT_INT(band);
2d66bee7 425 DRIVER_STATE_PRINT_INT(power_level);
2d66bee7
AN		 426 DRIVER_STATE_PRINT_INT(sg_enabled);
427 DRIVER_STATE_PRINT_INT(enable_11a);
428 DRIVER_STATE_PRINT_INT(noise);
2d66bee7
AN		 429 DRIVER_STATE_PRINT_HEX(ap_fw_ps_map);
430 DRIVER_STATE_PRINT_LHEX(ap_ps_map);
431 DRIVER_STATE_PRINT_HEX(quirks);
432 DRIVER_STATE_PRINT_HEX(irq);
433 DRIVER_STATE_PRINT_HEX(ref_clock);
434 DRIVER_STATE_PRINT_HEX(tcxo_clock);
435 DRIVER_STATE_PRINT_HEX(hw_pg_ver);
436 DRIVER_STATE_PRINT_HEX(platform_quirks);
437 DRIVER_STATE_PRINT_HEX(chip.id);
438 DRIVER_STATE_PRINT_STR(chip.fw_ver_str);
d3eff81d 439 DRIVER_STATE_PRINT_INT(sched_scanning);
2d66bee7
AN		 440
441#undef DRIVER_STATE_PRINT_INT
442#undef DRIVER_STATE_PRINT_LONG
443#undef DRIVER_STATE_PRINT_HEX
444#undef DRIVER_STATE_PRINT_LHEX
445#undef DRIVER_STATE_PRINT_STR
446#undef DRIVER_STATE_PRINT
c99f895a 447#undef DRIVER_STATE_BUF_LEN
2d66bee7
AN		 448
449 mutex_unlock(&wl->mutex);
450
c99f895a
LC		 451 ret = simple_read_from_buffer(user_buf, count, ppos, buf, res);
452 kfree(buf);
453 return ret;
2d66bee7
AN		 454}
455
456static const struct file_operations driver_state_ops = {
457 .read = driver_state_read,
458 .open = wl1271_open_file_generic,
459 .llseek = default_llseek,
460};
461
fa5e1375
EP		 462static ssize_t vifs_state_read(struct file *file, char __user *user_buf,
463 size_t count, loff_t *ppos)
464{
465 struct wl1271 *wl = file->private_data;
466 struct wl12xx_vif *wlvif;
467 int ret, res = 0;
468 const int buf_size = 4096;
469 char *buf;
470 char tmp_buf[64];
471
472 buf = kzalloc(buf_size, GFP_KERNEL);
473 if (!buf)
474 return -ENOMEM;
475
476 mutex_lock(&wl->mutex);
477
478#define VIF_STATE_PRINT(x, fmt) \
479 (res += scnprintf(buf + res, buf_size - res, \
480 #x " = " fmt "\n", wlvif->x))
481
482#define VIF_STATE_PRINT_LONG(x) VIF_STATE_PRINT(x, "%ld")
483#define VIF_STATE_PRINT_INT(x) VIF_STATE_PRINT(x, "%d")
484#define VIF_STATE_PRINT_STR(x) VIF_STATE_PRINT(x, "%s")
485#define VIF_STATE_PRINT_LHEX(x) VIF_STATE_PRINT(x, "0x%lx")
486#define VIF_STATE_PRINT_LLHEX(x) VIF_STATE_PRINT(x, "0x%llx")
487#define VIF_STATE_PRINT_HEX(x) VIF_STATE_PRINT(x, "0x%x")
488
489#define VIF_STATE_PRINT_NSTR(x, len) \
490 do { \
491 memset(tmp_buf, 0, sizeof(tmp_buf)); \
492 memcpy(tmp_buf, wlvif->x, \
493 min_t(u8, len, sizeof(tmp_buf) - 1)); \
494 res += scnprintf(buf + res, buf_size - res, \
495 #x " = %s\n", tmp_buf); \
496 } while (0)
497
498 wl12xx_for_each_wlvif(wl, wlvif) {
499 VIF_STATE_PRINT_INT(role_id);
500 VIF_STATE_PRINT_INT(bss_type);
501 VIF_STATE_PRINT_LHEX(flags);
502 VIF_STATE_PRINT_INT(p2p);
503 VIF_STATE_PRINT_INT(dev_role_id);
504 VIF_STATE_PRINT_INT(dev_hlid);
505
506 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
507 wlvif->bss_type == BSS_TYPE_IBSS) {
508 VIF_STATE_PRINT_INT(sta.hlid);
509 VIF_STATE_PRINT_INT(sta.ba_rx_bitmap);
510 VIF_STATE_PRINT_INT(sta.basic_rate_idx);
511 VIF_STATE_PRINT_INT(sta.ap_rate_idx);
512 VIF_STATE_PRINT_INT(sta.p2p_rate_idx);
513 } else {
514 VIF_STATE_PRINT_INT(ap.global_hlid);
515 VIF_STATE_PRINT_INT(ap.bcast_hlid);
516 VIF_STATE_PRINT_LHEX(ap.sta_hlid_map[0]);
517 VIF_STATE_PRINT_INT(ap.mgmt_rate_idx);
518 VIF_STATE_PRINT_INT(ap.bcast_rate_idx);
519 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[0]);
520 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[1]);
521 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[2]);
522 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[3]);
523 }
524 VIF_STATE_PRINT_INT(last_tx_hlid);
525 VIF_STATE_PRINT_LHEX(links_map[0]);
526 VIF_STATE_PRINT_NSTR(ssid, wlvif->ssid_len);
527 VIF_STATE_PRINT_INT(band);
528 VIF_STATE_PRINT_INT(channel);
529 VIF_STATE_PRINT_HEX(bitrate_masks[0]);
530 VIF_STATE_PRINT_HEX(bitrate_masks[1]);
531 VIF_STATE_PRINT_HEX(basic_rate_set);
532 VIF_STATE_PRINT_HEX(basic_rate);
533 VIF_STATE_PRINT_HEX(rate_set);
534 VIF_STATE_PRINT_INT(beacon_int);
535 VIF_STATE_PRINT_INT(default_key);
536 VIF_STATE_PRINT_INT(aid);
537 VIF_STATE_PRINT_INT(session_counter);
fa5e1375
EP		 538 VIF_STATE_PRINT_INT(psm_entry_retry);
539 VIF_STATE_PRINT_INT(power_level);
540 VIF_STATE_PRINT_INT(rssi_thold);
541 VIF_STATE_PRINT_INT(last_rssi_event);
542 VIF_STATE_PRINT_INT(ba_support);
543 VIF_STATE_PRINT_INT(ba_allowed);
544 VIF_STATE_PRINT_LLHEX(tx_security_seq);
545 VIF_STATE_PRINT_INT(tx_security_last_seq_lsb);
546 }
547
548#undef VIF_STATE_PRINT_INT
549#undef VIF_STATE_PRINT_LONG
550#undef VIF_STATE_PRINT_HEX
551#undef VIF_STATE_PRINT_LHEX
552#undef VIF_STATE_PRINT_LLHEX
553#undef VIF_STATE_PRINT_STR
554#undef VIF_STATE_PRINT_NSTR
555#undef VIF_STATE_PRINT
556
557 mutex_unlock(&wl->mutex);
558
559 ret = simple_read_from_buffer(user_buf, count, ppos, buf, res);
560 kfree(buf);
561 return ret;
562}
563
564static const struct file_operations vifs_state_ops = {
565 .read = vifs_state_read,
566 .open = wl1271_open_file_generic,
567 .llseek = default_llseek,
568};
569
1fe9e246
EP		 570static ssize_t dtim_interval_read(struct file *file, char __user *user_buf,
571 size_t count, loff_t *ppos)
572{
573 struct wl1271 *wl = file->private_data;
574 u8 value;
575
576 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_DTIM ||
577 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM)
578 value = wl->conf.conn.listen_interval;
579 else
580 value = 0;
581
582 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
583}
584
585static ssize_t dtim_interval_write(struct file *file,
586 const char __user *user_buf,
587 size_t count, loff_t *ppos)
588{
589 struct wl1271 *wl = file->private_data;
1fe9e246
EP		 590 unsigned long value;
591 int ret;
592
b6883582 593 ret = kstrtoul_from_user(user_buf, count, 10, &value);
1fe9e246
EP		 594 if (ret < 0) {
595 wl1271_warning("illegal value for dtim_interval");
596 return -EINVAL;
597 }
598
599 if (value < 1 || value > 10) {
600 wl1271_warning("dtim value is not in valid range");
601 return -ERANGE;
602 }
603
604 mutex_lock(&wl->mutex);
605
606 wl->conf.conn.listen_interval = value;
607 /* for some reason there are different event types for 1 and >1 */
608 if (value == 1)
609 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_DTIM;
610 else
611 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM;
612
613 /*
614 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
615 * take effect on the next time we enter psm.
616 */
617 mutex_unlock(&wl->mutex);
618 return count;
619}
620
621static const struct file_operations dtim_interval_ops = {
622 .read = dtim_interval_read,
623 .write = dtim_interval_write,
624 .open = wl1271_open_file_generic,
625 .llseek = default_llseek,
626};
627
628static ssize_t beacon_interval_read(struct file *file, char __user *user_buf,
629 size_t count, loff_t *ppos)
630{
631 struct wl1271 *wl = file->private_data;
632 u8 value;
633
634 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_BEACON ||
635 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_BEACONS)
636 value = wl->conf.conn.listen_interval;
637 else
638 value = 0;
639
640 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
641}
642
643static ssize_t beacon_interval_write(struct file *file,
644 const char __user *user_buf,
645 size_t count, loff_t *ppos)
646{
647 struct wl1271 *wl = file->private_data;
1fe9e246
EP		 648 unsigned long value;
649 int ret;
650
b6883582 651 ret = kstrtoul_from_user(user_buf, count, 10, &value);
1fe9e246
EP		 652 if (ret < 0) {
653 wl1271_warning("illegal value for beacon_interval");
654 return -EINVAL;
655 }
656
657 if (value < 1 || value > 255) {
658 wl1271_warning("beacon interval value is not in valid range");
659 return -ERANGE;
660 }
661
662 mutex_lock(&wl->mutex);
663
664 wl->conf.conn.listen_interval = value;
665 /* for some reason there are different event types for 1 and >1 */
666 if (value == 1)
667 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_BEACON;
668 else
669 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_BEACONS;
670
671 /*
672 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
673 * take effect on the next time we enter psm.
674 */
675 mutex_unlock(&wl->mutex);
676 return count;
677}
678
679static const struct file_operations beacon_interval_ops = {
680 .read = beacon_interval_read,
681 .write = beacon_interval_write,
682 .open = wl1271_open_file_generic,
683 .llseek = default_llseek,
684};
685
c84368e0
EP		 686static ssize_t rx_streaming_interval_write(struct file *file,
687 const char __user *user_buf,
688 size_t count, loff_t *ppos)
689{
690 struct wl1271 *wl = file->private_data;
9eb599e9 691 struct wl12xx_vif *wlvif;
c84368e0
EP		 692 unsigned long value;
693 int ret;
694
b6883582 695 ret = kstrtoul_from_user(user_buf, count, 10, &value);
c84368e0
EP		 696 if (ret < 0) {
697 wl1271_warning("illegal value in rx_streaming_interval!");
698 return -EINVAL;
699 }
700
701 /* valid values: 0, 10-100 */
702 if (value && (value < 10 || value > 100)) {
703 wl1271_warning("value is not in range!");
704 return -ERANGE;
705 }
706
707 mutex_lock(&wl->mutex);
708
709 wl->conf.rx_streaming.interval = value;
710
711 ret = wl1271_ps_elp_wakeup(wl);
712 if (ret < 0)
713 goto out;
714
9eb599e9
EP		 715 wl12xx_for_each_wlvif_sta(wl, wlvif) {
716 wl1271_recalc_rx_streaming(wl, wlvif);
717 }
c84368e0
EP		 718
719 wl1271_ps_elp_sleep(wl);
720out:
721 mutex_unlock(&wl->mutex);
722 return count;
723}
724
725static ssize_t rx_streaming_interval_read(struct file *file,
726 char __user *userbuf,
727 size_t count, loff_t *ppos)
728{
729 struct wl1271 *wl = file->private_data;
730 return wl1271_format_buffer(userbuf, count, ppos,
731 "%d\n", wl->conf.rx_streaming.interval);
732}
733
734static const struct file_operations rx_streaming_interval_ops = {
735 .read = rx_streaming_interval_read,
736 .write = rx_streaming_interval_write,
737 .open = wl1271_open_file_generic,
738 .llseek = default_llseek,
739};
740
741static ssize_t rx_streaming_always_write(struct file *file,
742 const char __user *user_buf,
743 size_t count, loff_t *ppos)
744{
745 struct wl1271 *wl = file->private_data;
9eb599e9 746 struct wl12xx_vif *wlvif;
c84368e0
EP		 747 unsigned long value;
748 int ret;
749
b6883582 750 ret = kstrtoul_from_user(user_buf, count, 10, &value);
c84368e0
EP		 751 if (ret < 0) {
752 wl1271_warning("illegal value in rx_streaming_write!");
753 return -EINVAL;
754 }
755
756 /* valid values: 0, 10-100 */
757 if (!(value == 0 || value == 1)) {
758 wl1271_warning("value is not in valid!");
759 return -EINVAL;
760 }
761
762 mutex_lock(&wl->mutex);
763
764 wl->conf.rx_streaming.always = value;
765
766 ret = wl1271_ps_elp_wakeup(wl);
767 if (ret < 0)
768 goto out;
769
9eb599e9
EP		 770 wl12xx_for_each_wlvif_sta(wl, wlvif) {
771 wl1271_recalc_rx_streaming(wl, wlvif);
772 }
c84368e0
EP		 773
774 wl1271_ps_elp_sleep(wl);
775out:
776 mutex_unlock(&wl->mutex);
777 return count;
778}
779
780static ssize_t rx_streaming_always_read(struct file *file,
781 char __user *userbuf,
782 size_t count, loff_t *ppos)
783{
784 struct wl1271 *wl = file->private_data;
785 return wl1271_format_buffer(userbuf, count, ppos,
786 "%d\n", wl->conf.rx_streaming.always);
787}
788
789static const struct file_operations rx_streaming_always_ops = {
790 .read = rx_streaming_always_read,
791 .write = rx_streaming_always_write,
792 .open = wl1271_open_file_generic,
793 .llseek = default_llseek,
794};
795
a0a52156
EP		 796static ssize_t beacon_filtering_write(struct file *file,
797 const char __user *user_buf,
798 size_t count, loff_t *ppos)
799{
800 struct wl1271 *wl = file->private_data;
0603d891 801 struct wl12xx_vif *wlvif;
a0a52156
EP		 802 char buf[10];
803 size_t len;
804 unsigned long value;
805 int ret;
806
807 len = min(count, sizeof(buf) - 1);
808 if (copy_from_user(buf, user_buf, len))
809 return -EFAULT;
810 buf[len] = '\0';
811
812 ret = kstrtoul(buf, 0, &value);
813 if (ret < 0) {
814 wl1271_warning("illegal value for beacon_filtering!");
815 return -EINVAL;
816 }
817
818 mutex_lock(&wl->mutex);
819
820 ret = wl1271_ps_elp_wakeup(wl);
821 if (ret < 0)
822 goto out;
823
6e8cd331
EP		 824 wl12xx_for_each_wlvif(wl, wlvif) {
825 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, !!value);
826 }
a0a52156
EP		 827
828 wl1271_ps_elp_sleep(wl);
829out:
830 mutex_unlock(&wl->mutex);
831 return count;
832}
833
834static const struct file_operations beacon_filtering_ops = {
835 .write = beacon_filtering_write,
836 .open = wl1271_open_file_generic,
837 .llseek = default_llseek,
838};
839
3c2c04a1
EP		 840static int wl1271_debugfs_add_files(struct wl1271 *wl,
841 struct dentry *rootdir)
f5fc0f86
LC		 842{
843 int ret = 0;
c84368e0 844 struct dentry *entry, *stats, *streaming;
7cb2cea9 845
3c2c04a1 846 stats = debugfs_create_dir("fw-statistics", rootdir);
7cb2cea9
EP		 847 if (!stats || IS_ERR(stats)) {
848 entry = stats;
849 goto err;
850 }
f5fc0f86
LC		 851
852 DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow);
853
854 DEBUGFS_FWSTATS_ADD(rx, out_of_mem);
855 DEBUGFS_FWSTATS_ADD(rx, hdr_overflow);
856 DEBUGFS_FWSTATS_ADD(rx, hw_stuck);
857 DEBUGFS_FWSTATS_ADD(rx, dropped);
858 DEBUGFS_FWSTATS_ADD(rx, fcs_err);
859 DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig);
860 DEBUGFS_FWSTATS_ADD(rx, path_reset);
861 DEBUGFS_FWSTATS_ADD(rx, reset_counter);
862
863 DEBUGFS_FWSTATS_ADD(dma, rx_requested);
864 DEBUGFS_FWSTATS_ADD(dma, rx_errors);
865 DEBUGFS_FWSTATS_ADD(dma, tx_requested);
866 DEBUGFS_FWSTATS_ADD(dma, tx_errors);
867
868 DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt);
869 DEBUGFS_FWSTATS_ADD(isr, fiqs);
870 DEBUGFS_FWSTATS_ADD(isr, rx_headers);
871 DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow);
872 DEBUGFS_FWSTATS_ADD(isr, rx_rdys);
873 DEBUGFS_FWSTATS_ADD(isr, irqs);
874 DEBUGFS_FWSTATS_ADD(isr, tx_procs);
875 DEBUGFS_FWSTATS_ADD(isr, decrypt_done);
876 DEBUGFS_FWSTATS_ADD(isr, dma0_done);
877 DEBUGFS_FWSTATS_ADD(isr, dma1_done);
878 DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete);
879 DEBUGFS_FWSTATS_ADD(isr, commands);
880 DEBUGFS_FWSTATS_ADD(isr, rx_procs);
881 DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes);
882 DEBUGFS_FWSTATS_ADD(isr, host_acknowledges);
883 DEBUGFS_FWSTATS_ADD(isr, pci_pm);
884 DEBUGFS_FWSTATS_ADD(isr, wakeups);
885 DEBUGFS_FWSTATS_ADD(isr, low_rssi);
886
887 DEBUGFS_FWSTATS_ADD(wep, addr_key_count);
888 DEBUGFS_FWSTATS_ADD(wep, default_key_count);
889 /* skipping wep.reserved */
890 DEBUGFS_FWSTATS_ADD(wep, key_not_found);
891 DEBUGFS_FWSTATS_ADD(wep, decrypt_fail);
892 DEBUGFS_FWSTATS_ADD(wep, packets);
893 DEBUGFS_FWSTATS_ADD(wep, interrupt);
894
895 DEBUGFS_FWSTATS_ADD(pwr, ps_enter);
896 DEBUGFS_FWSTATS_ADD(pwr, elp_enter);
897 DEBUGFS_FWSTATS_ADD(pwr, missing_bcns);
898 DEBUGFS_FWSTATS_ADD(pwr, wake_on_host);
899 DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp);
900 DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps);
901 DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps);
902 DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons);
903 DEBUGFS_FWSTATS_ADD(pwr, power_save_off);
904 DEBUGFS_FWSTATS_ADD(pwr, enable_ps);
905 DEBUGFS_FWSTATS_ADD(pwr, disable_ps);
906 DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps);
907 /* skipping cont_miss_bcns_spread for now */
908 DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons);
909
910 DEBUGFS_FWSTATS_ADD(mic, rx_pkts);
911 DEBUGFS_FWSTATS_ADD(mic, calc_failure);
912
913 DEBUGFS_FWSTATS_ADD(aes, encrypt_fail);
914 DEBUGFS_FWSTATS_ADD(aes, decrypt_fail);
915 DEBUGFS_FWSTATS_ADD(aes, encrypt_packets);
916 DEBUGFS_FWSTATS_ADD(aes, decrypt_packets);
917 DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt);
918 DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt);
919
920 DEBUGFS_FWSTATS_ADD(event, heart_beat);
921 DEBUGFS_FWSTATS_ADD(event, calibration);
922 DEBUGFS_FWSTATS_ADD(event, rx_mismatch);
923 DEBUGFS_FWSTATS_ADD(event, rx_mem_empty);
924 DEBUGFS_FWSTATS_ADD(event, rx_pool);
925 DEBUGFS_FWSTATS_ADD(event, oom_late);
926 DEBUGFS_FWSTATS_ADD(event, phy_transmit_error);
927 DEBUGFS_FWSTATS_ADD(event, tx_stuck);
928
929 DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts);
930 DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts);
931 DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime);
932 DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn);
933 DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn);
934 DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization);
935 DEBUGFS_FWSTATS_ADD(ps, upsd_utilization);
936
937 DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop);
938 DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data);
939 DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
940 DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data);
941 DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data);
942
3c2c04a1
EP		 943 DEBUGFS_ADD(tx_queue_len, rootdir);
944 DEBUGFS_ADD(retry_count, rootdir);
945 DEBUGFS_ADD(excessive_retries, rootdir);
f5fc0f86 946
3c2c04a1 947 DEBUGFS_ADD(gpio_power, rootdir);
2dc5a5c2 948 DEBUGFS_ADD(start_recovery, rootdir);
2d66bee7 949 DEBUGFS_ADD(driver_state, rootdir);
fa5e1375 950 DEBUGFS_ADD(vifs_state, rootdir);
1fe9e246
EP		 951 DEBUGFS_ADD(dtim_interval, rootdir);
952 DEBUGFS_ADD(beacon_interval, rootdir);
a0a52156 953 DEBUGFS_ADD(beacon_filtering, rootdir);
1faff895 954 DEBUGFS_ADD(dynamic_ps_timeout, rootdir);
98b2a684 955
c84368e0
EP		 956 streaming = debugfs_create_dir("rx_streaming", rootdir);
957 if (!streaming || IS_ERR(streaming))
958 goto err;
959
960 DEBUGFS_ADD_PREFIX(rx_streaming, interval, streaming);
961 DEBUGFS_ADD_PREFIX(rx_streaming, always, streaming);
962
963
7cb2cea9
EP		 964 return 0;
965
966err:
967 if (IS_ERR(entry))
968 ret = PTR_ERR(entry);
969 else
970 ret = -ENOMEM;
f5fc0f86
LC		 971
972 return ret;
973}
974
975void wl1271_debugfs_reset(struct wl1271 *wl)
976{
3c2c04a1 977 if (!wl->stats.fw_stats)
43a598d5
LC		 978 return;
979
f5fc0f86
LC		 980 memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
981 wl->stats.retry_count = 0;
982 wl->stats.excessive_retries = 0;
983}
984
985int wl1271_debugfs_init(struct wl1271 *wl)
986{
987 int ret;
3c2c04a1 988 struct dentry *rootdir;
f5fc0f86 989
3c2c04a1
EP		 990 rootdir = debugfs_create_dir(KBUILD_MODNAME,
991 wl->hw->wiphy->debugfsdir);
f5fc0f86 992
3c2c04a1
EP		 993 if (IS_ERR(rootdir)) {
994 ret = PTR_ERR(rootdir);
f5fc0f86
LC		 995 goto err;
996 }
997
f5fc0f86
LC		 998 wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats),
999 GFP_KERNEL);
1000
1001 if (!wl->stats.fw_stats) {
1002 ret = -ENOMEM;
1003 goto err_fw;
1004 }
1005
1006 wl->stats.fw_stats_update = jiffies;
1007
3c2c04a1 1008 ret = wl1271_debugfs_add_files(wl, rootdir);
f5fc0f86
LC		 1009
1010 if (ret < 0)
1011 goto err_file;
1012
1013 return 0;
1014
1015err_file:
1016 kfree(wl->stats.fw_stats);
1017 wl->stats.fw_stats = NULL;
1018
1019err_fw:
3c2c04a1 1020 debugfs_remove_recursive(rootdir);
f5fc0f86
LC		 1021
1022err:
1023 return ret;
1024}
1025
1026void wl1271_debugfs_exit(struct wl1271 *wl)
1027{
f5fc0f86
LC		 1028 kfree(wl->stats.fw_stats);
1029 wl->stats.fw_stats = NULL;
f5fc0f86 1030}
Linux 6.x block layer and io_uring tree(s)