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