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