2 * This file is part of wl1271
4 * Copyright (C) 2009 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
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.
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.
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
26 #include <linux/skbuff.h>
27 #include <linux/slab.h>
36 #define WL1271_DEBUGFS_STATS_LIFETIME 1000
38 /* debugfs macros idea from mac80211 */
39 #define DEBUGFS_FORMAT_BUFFER_SIZE 100
40 static int wl1271_format_buffer(char __user *userbuf, size_t count,
41 loff_t *ppos, char *fmt, ...)
44 char buf[DEBUGFS_FORMAT_BUFFER_SIZE];
48 res = vscnprintf(buf, sizeof(buf), fmt, args);
51 return simple_read_from_buffer(userbuf, count, ppos, buf, res);
54 #define DEBUGFS_READONLY_FILE(name, fmt, value...) \
55 static ssize_t name## _read(struct file *file, char __user *userbuf, \
56 size_t count, loff_t *ppos) \
58 struct wl1271 *wl = file->private_data; \
59 return wl1271_format_buffer(userbuf, count, ppos, \
63 static const struct file_operations name## _ops = { \
64 .read = name## _read, \
65 .open = wl1271_open_file_generic, \
66 .llseek = generic_file_llseek, \
69 #define DEBUGFS_ADD(name, parent) \
70 entry = debugfs_create_file(#name, 0400, parent, \
72 if (!entry || IS_ERR(entry)) \
75 #define DEBUGFS_ADD_PREFIX(prefix, name, parent) \
77 entry = debugfs_create_file(#name, 0400, parent, \
78 wl, &prefix## _## name## _ops); \
79 if (!entry || IS_ERR(entry)) \
83 #define DEBUGFS_FWSTATS_FILE(sub, name, fmt) \
84 static ssize_t sub## _ ##name## _read(struct file *file, \
85 char __user *userbuf, \
86 size_t count, loff_t *ppos) \
88 struct wl1271 *wl = file->private_data; \
90 wl1271_debugfs_update_stats(wl); \
92 return wl1271_format_buffer(userbuf, count, ppos, fmt "\n", \
93 wl->stats.fw_stats->sub.name); \
96 static const struct file_operations sub## _ ##name## _ops = { \
97 .read = sub## _ ##name## _read, \
98 .open = wl1271_open_file_generic, \
99 .llseek = generic_file_llseek, \
102 #define DEBUGFS_FWSTATS_ADD(sub, name) \
103 DEBUGFS_ADD(sub## _ ##name, stats)
105 static void wl1271_debugfs_update_stats(struct wl1271 *wl)
109 mutex_lock(&wl->mutex);
111 ret = wl1271_ps_elp_wakeup(wl);
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;
122 wl1271_ps_elp_sleep(wl);
125 mutex_unlock(&wl->mutex);
128 static int wl1271_open_file_generic(struct inode *inode, struct file *file)
130 file->private_data = inode->i_private;
134 DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, "%u");
136 DEBUGFS_FWSTATS_FILE(rx, out_of_mem, "%u");
137 DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, "%u");
138 DEBUGFS_FWSTATS_FILE(rx, hw_stuck, "%u");
139 DEBUGFS_FWSTATS_FILE(rx, dropped, "%u");
140 DEBUGFS_FWSTATS_FILE(rx, fcs_err, "%u");
141 DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, "%u");
142 DEBUGFS_FWSTATS_FILE(rx, path_reset, "%u");
143 DEBUGFS_FWSTATS_FILE(rx, reset_counter, "%u");
145 DEBUGFS_FWSTATS_FILE(dma, rx_requested, "%u");
146 DEBUGFS_FWSTATS_FILE(dma, rx_errors, "%u");
147 DEBUGFS_FWSTATS_FILE(dma, tx_requested, "%u");
148 DEBUGFS_FWSTATS_FILE(dma, tx_errors, "%u");
150 DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, "%u");
151 DEBUGFS_FWSTATS_FILE(isr, fiqs, "%u");
152 DEBUGFS_FWSTATS_FILE(isr, rx_headers, "%u");
153 DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, "%u");
154 DEBUGFS_FWSTATS_FILE(isr, rx_rdys, "%u");
155 DEBUGFS_FWSTATS_FILE(isr, irqs, "%u");
156 DEBUGFS_FWSTATS_FILE(isr, tx_procs, "%u");
157 DEBUGFS_FWSTATS_FILE(isr, decrypt_done, "%u");
158 DEBUGFS_FWSTATS_FILE(isr, dma0_done, "%u");
159 DEBUGFS_FWSTATS_FILE(isr, dma1_done, "%u");
160 DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, "%u");
161 DEBUGFS_FWSTATS_FILE(isr, commands, "%u");
162 DEBUGFS_FWSTATS_FILE(isr, rx_procs, "%u");
163 DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, "%u");
164 DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, "%u");
165 DEBUGFS_FWSTATS_FILE(isr, pci_pm, "%u");
166 DEBUGFS_FWSTATS_FILE(isr, wakeups, "%u");
167 DEBUGFS_FWSTATS_FILE(isr, low_rssi, "%u");
169 DEBUGFS_FWSTATS_FILE(wep, addr_key_count, "%u");
170 DEBUGFS_FWSTATS_FILE(wep, default_key_count, "%u");
171 /* skipping wep.reserved */
172 DEBUGFS_FWSTATS_FILE(wep, key_not_found, "%u");
173 DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, "%u");
174 DEBUGFS_FWSTATS_FILE(wep, packets, "%u");
175 DEBUGFS_FWSTATS_FILE(wep, interrupt, "%u");
177 DEBUGFS_FWSTATS_FILE(pwr, ps_enter, "%u");
178 DEBUGFS_FWSTATS_FILE(pwr, elp_enter, "%u");
179 DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, "%u");
180 DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, "%u");
181 DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, "%u");
182 DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, "%u");
183 DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, "%u");
184 DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, "%u");
185 DEBUGFS_FWSTATS_FILE(pwr, power_save_off, "%u");
186 DEBUGFS_FWSTATS_FILE(pwr, enable_ps, "%u");
187 DEBUGFS_FWSTATS_FILE(pwr, disable_ps, "%u");
188 DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, "%u");
189 /* skipping cont_miss_bcns_spread for now */
190 DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, "%u");
192 DEBUGFS_FWSTATS_FILE(mic, rx_pkts, "%u");
193 DEBUGFS_FWSTATS_FILE(mic, calc_failure, "%u");
195 DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, "%u");
196 DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, "%u");
197 DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, "%u");
198 DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, "%u");
199 DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, "%u");
200 DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, "%u");
202 DEBUGFS_FWSTATS_FILE(event, heart_beat, "%u");
203 DEBUGFS_FWSTATS_FILE(event, calibration, "%u");
204 DEBUGFS_FWSTATS_FILE(event, rx_mismatch, "%u");
205 DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, "%u");
206 DEBUGFS_FWSTATS_FILE(event, rx_pool, "%u");
207 DEBUGFS_FWSTATS_FILE(event, oom_late, "%u");
208 DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, "%u");
209 DEBUGFS_FWSTATS_FILE(event, tx_stuck, "%u");
211 DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, "%u");
212 DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, "%u");
213 DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, "%u");
214 DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, "%u");
215 DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, "%u");
216 DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, "%u");
217 DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, "%u");
219 DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, "%u");
220 DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, "%u");
221 DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data, "%u");
222 DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, "%u");
223 DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, "%u");
225 DEBUGFS_READONLY_FILE(retry_count, "%u", wl->stats.retry_count);
226 DEBUGFS_READONLY_FILE(excessive_retries, "%u",
227 wl->stats.excessive_retries);
229 static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
230 size_t count, loff_t *ppos)
232 struct wl1271 *wl = file->private_data;
237 queue_len = wl1271_tx_total_queue_count(wl);
239 res = scnprintf(buf, sizeof(buf), "%u\n", queue_len);
240 return simple_read_from_buffer(userbuf, count, ppos, buf, res);
243 static const struct file_operations tx_queue_len_ops = {
244 .read = tx_queue_len_read,
245 .open = wl1271_open_file_generic,
246 .llseek = default_llseek,
249 static ssize_t gpio_power_read(struct file *file, char __user *user_buf,
250 size_t count, loff_t *ppos)
252 struct wl1271 *wl = file->private_data;
253 bool state = test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
258 res = scnprintf(buf, sizeof(buf), "%d\n", state);
260 return simple_read_from_buffer(user_buf, count, ppos, buf, res);
263 static ssize_t gpio_power_write(struct file *file,
264 const char __user *user_buf,
265 size_t count, loff_t *ppos)
267 struct wl1271 *wl = file->private_data;
273 len = min(count, sizeof(buf) - 1);
274 if (copy_from_user(buf, user_buf, len)) {
279 ret = kstrtoul(buf, 0, &value);
281 wl1271_warning("illegal value in gpio_power");
285 mutex_lock(&wl->mutex);
290 wl1271_power_off(wl);
292 mutex_unlock(&wl->mutex);
296 static 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,
303 static ssize_t start_recovery_write(struct file *file,
304 const char __user *user_buf,
305 size_t count, loff_t *ppos)
307 struct wl1271 *wl = file->private_data;
309 mutex_lock(&wl->mutex);
310 wl12xx_queue_recovery_work(wl);
311 mutex_unlock(&wl->mutex);
316 static const struct file_operations start_recovery_ops = {
317 .write = start_recovery_write,
318 .open = wl1271_open_file_generic,
319 .llseek = default_llseek,
322 static ssize_t driver_state_read(struct file *file, char __user *user_buf,
323 size_t count, loff_t *ppos)
325 struct wl1271 *wl = file->private_data;
329 mutex_lock(&wl->mutex);
331 #define DRIVER_STATE_PRINT(x, fmt) \
332 (res += scnprintf(buf + res, sizeof(buf) - res,\
333 #x " = " fmt "\n", wl->x))
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")
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(tx_security_last_seq_lsb);
358 DRIVER_STATE_PRINT_INT(rx_counter);
359 DRIVER_STATE_PRINT_INT(session_counter);
360 DRIVER_STATE_PRINT_INT(state);
361 DRIVER_STATE_PRINT_INT(bss_type);
362 DRIVER_STATE_PRINT_INT(channel);
363 DRIVER_STATE_PRINT_HEX(rate_set);
364 DRIVER_STATE_PRINT_HEX(basic_rate_set);
365 DRIVER_STATE_PRINT_HEX(basic_rate);
366 DRIVER_STATE_PRINT_INT(band);
367 DRIVER_STATE_PRINT_INT(beacon_int);
368 DRIVER_STATE_PRINT_INT(psm_entry_retry);
369 DRIVER_STATE_PRINT_INT(ps_poll_failures);
370 DRIVER_STATE_PRINT_INT(power_level);
371 DRIVER_STATE_PRINT_INT(rssi_thold);
372 DRIVER_STATE_PRINT_INT(last_rssi_event);
373 DRIVER_STATE_PRINT_INT(sg_enabled);
374 DRIVER_STATE_PRINT_INT(enable_11a);
375 DRIVER_STATE_PRINT_INT(noise);
376 DRIVER_STATE_PRINT_LHEX(ap_hlid_map[0]);
377 DRIVER_STATE_PRINT_INT(last_tx_hlid);
378 DRIVER_STATE_PRINT_INT(ba_support);
379 DRIVER_STATE_PRINT_HEX(ba_rx_bitmap);
380 DRIVER_STATE_PRINT_HEX(ap_fw_ps_map);
381 DRIVER_STATE_PRINT_LHEX(ap_ps_map);
382 DRIVER_STATE_PRINT_HEX(quirks);
383 DRIVER_STATE_PRINT_HEX(irq);
384 DRIVER_STATE_PRINT_HEX(ref_clock);
385 DRIVER_STATE_PRINT_HEX(tcxo_clock);
386 DRIVER_STATE_PRINT_HEX(hw_pg_ver);
387 DRIVER_STATE_PRINT_HEX(platform_quirks);
388 DRIVER_STATE_PRINT_HEX(chip.id);
389 DRIVER_STATE_PRINT_STR(chip.fw_ver_str);
390 DRIVER_STATE_PRINT_INT(sched_scanning);
392 #undef DRIVER_STATE_PRINT_INT
393 #undef DRIVER_STATE_PRINT_LONG
394 #undef DRIVER_STATE_PRINT_HEX
395 #undef DRIVER_STATE_PRINT_LHEX
396 #undef DRIVER_STATE_PRINT_STR
397 #undef DRIVER_STATE_PRINT
399 mutex_unlock(&wl->mutex);
401 return simple_read_from_buffer(user_buf, count, ppos, buf, res);
404 static const struct file_operations driver_state_ops = {
405 .read = driver_state_read,
406 .open = wl1271_open_file_generic,
407 .llseek = default_llseek,
410 static ssize_t dtim_interval_read(struct file *file, char __user *user_buf,
411 size_t count, loff_t *ppos)
413 struct wl1271 *wl = file->private_data;
416 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_DTIM ||
417 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM)
418 value = wl->conf.conn.listen_interval;
422 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
425 static ssize_t dtim_interval_write(struct file *file,
426 const char __user *user_buf,
427 size_t count, loff_t *ppos)
429 struct wl1271 *wl = file->private_data;
435 len = min(count, sizeof(buf) - 1);
436 if (copy_from_user(buf, user_buf, len))
440 ret = kstrtoul(buf, 0, &value);
442 wl1271_warning("illegal value for dtim_interval");
446 if (value < 1 || value > 10) {
447 wl1271_warning("dtim value is not in valid range");
451 mutex_lock(&wl->mutex);
453 wl->conf.conn.listen_interval = value;
454 /* for some reason there are different event types for 1 and >1 */
456 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_DTIM;
458 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM;
461 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
462 * take effect on the next time we enter psm.
464 mutex_unlock(&wl->mutex);
468 static const struct file_operations dtim_interval_ops = {
469 .read = dtim_interval_read,
470 .write = dtim_interval_write,
471 .open = wl1271_open_file_generic,
472 .llseek = default_llseek,
475 static ssize_t beacon_interval_read(struct file *file, char __user *user_buf,
476 size_t count, loff_t *ppos)
478 struct wl1271 *wl = file->private_data;
481 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_BEACON ||
482 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_BEACONS)
483 value = wl->conf.conn.listen_interval;
487 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
490 static ssize_t beacon_interval_write(struct file *file,
491 const char __user *user_buf,
492 size_t count, loff_t *ppos)
494 struct wl1271 *wl = file->private_data;
500 len = min(count, sizeof(buf) - 1);
501 if (copy_from_user(buf, user_buf, len))
505 ret = kstrtoul(buf, 0, &value);
507 wl1271_warning("illegal value for beacon_interval");
511 if (value < 1 || value > 255) {
512 wl1271_warning("beacon interval value is not in valid range");
516 mutex_lock(&wl->mutex);
518 wl->conf.conn.listen_interval = value;
519 /* for some reason there are different event types for 1 and >1 */
521 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_BEACON;
523 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_BEACONS;
526 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
527 * take effect on the next time we enter psm.
529 mutex_unlock(&wl->mutex);
533 static const struct file_operations beacon_interval_ops = {
534 .read = beacon_interval_read,
535 .write = beacon_interval_write,
536 .open = wl1271_open_file_generic,
537 .llseek = default_llseek,
540 static ssize_t rx_streaming_interval_write(struct file *file,
541 const char __user *user_buf,
542 size_t count, loff_t *ppos)
544 struct wl1271 *wl = file->private_data;
550 len = min(count, sizeof(buf) - 1);
551 if (copy_from_user(buf, user_buf, len))
555 ret = kstrtoul(buf, 0, &value);
557 wl1271_warning("illegal value in rx_streaming_interval!");
561 /* valid values: 0, 10-100 */
562 if (value && (value < 10 || value > 100)) {
563 wl1271_warning("value is not in range!");
567 mutex_lock(&wl->mutex);
569 wl->conf.rx_streaming.interval = value;
571 ret = wl1271_ps_elp_wakeup(wl);
575 wl1271_recalc_rx_streaming(wl);
577 wl1271_ps_elp_sleep(wl);
579 mutex_unlock(&wl->mutex);
583 static ssize_t rx_streaming_interval_read(struct file *file,
584 char __user *userbuf,
585 size_t count, loff_t *ppos)
587 struct wl1271 *wl = file->private_data;
588 return wl1271_format_buffer(userbuf, count, ppos,
589 "%d\n", wl->conf.rx_streaming.interval);
592 static const struct file_operations rx_streaming_interval_ops = {
593 .read = rx_streaming_interval_read,
594 .write = rx_streaming_interval_write,
595 .open = wl1271_open_file_generic,
596 .llseek = default_llseek,
599 static ssize_t rx_streaming_always_write(struct file *file,
600 const char __user *user_buf,
601 size_t count, loff_t *ppos)
603 struct wl1271 *wl = file->private_data;
609 len = min(count, sizeof(buf) - 1);
610 if (copy_from_user(buf, user_buf, len))
614 ret = kstrtoul(buf, 0, &value);
616 wl1271_warning("illegal value in rx_streaming_write!");
620 /* valid values: 0, 10-100 */
621 if (!(value == 0 || value == 1)) {
622 wl1271_warning("value is not in valid!");
626 mutex_lock(&wl->mutex);
628 wl->conf.rx_streaming.always = value;
630 ret = wl1271_ps_elp_wakeup(wl);
634 wl1271_recalc_rx_streaming(wl);
636 wl1271_ps_elp_sleep(wl);
638 mutex_unlock(&wl->mutex);
642 static ssize_t rx_streaming_always_read(struct file *file,
643 char __user *userbuf,
644 size_t count, loff_t *ppos)
646 struct wl1271 *wl = file->private_data;
647 return wl1271_format_buffer(userbuf, count, ppos,
648 "%d\n", wl->conf.rx_streaming.always);
651 static const struct file_operations rx_streaming_always_ops = {
652 .read = rx_streaming_always_read,
653 .write = rx_streaming_always_write,
654 .open = wl1271_open_file_generic,
655 .llseek = default_llseek,
658 static int wl1271_debugfs_add_files(struct wl1271 *wl,
659 struct dentry *rootdir)
662 struct dentry *entry, *stats, *streaming;
664 stats = debugfs_create_dir("fw-statistics", rootdir);
665 if (!stats || IS_ERR(stats)) {
670 DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow);
672 DEBUGFS_FWSTATS_ADD(rx, out_of_mem);
673 DEBUGFS_FWSTATS_ADD(rx, hdr_overflow);
674 DEBUGFS_FWSTATS_ADD(rx, hw_stuck);
675 DEBUGFS_FWSTATS_ADD(rx, dropped);
676 DEBUGFS_FWSTATS_ADD(rx, fcs_err);
677 DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig);
678 DEBUGFS_FWSTATS_ADD(rx, path_reset);
679 DEBUGFS_FWSTATS_ADD(rx, reset_counter);
681 DEBUGFS_FWSTATS_ADD(dma, rx_requested);
682 DEBUGFS_FWSTATS_ADD(dma, rx_errors);
683 DEBUGFS_FWSTATS_ADD(dma, tx_requested);
684 DEBUGFS_FWSTATS_ADD(dma, tx_errors);
686 DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt);
687 DEBUGFS_FWSTATS_ADD(isr, fiqs);
688 DEBUGFS_FWSTATS_ADD(isr, rx_headers);
689 DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow);
690 DEBUGFS_FWSTATS_ADD(isr, rx_rdys);
691 DEBUGFS_FWSTATS_ADD(isr, irqs);
692 DEBUGFS_FWSTATS_ADD(isr, tx_procs);
693 DEBUGFS_FWSTATS_ADD(isr, decrypt_done);
694 DEBUGFS_FWSTATS_ADD(isr, dma0_done);
695 DEBUGFS_FWSTATS_ADD(isr, dma1_done);
696 DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete);
697 DEBUGFS_FWSTATS_ADD(isr, commands);
698 DEBUGFS_FWSTATS_ADD(isr, rx_procs);
699 DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes);
700 DEBUGFS_FWSTATS_ADD(isr, host_acknowledges);
701 DEBUGFS_FWSTATS_ADD(isr, pci_pm);
702 DEBUGFS_FWSTATS_ADD(isr, wakeups);
703 DEBUGFS_FWSTATS_ADD(isr, low_rssi);
705 DEBUGFS_FWSTATS_ADD(wep, addr_key_count);
706 DEBUGFS_FWSTATS_ADD(wep, default_key_count);
707 /* skipping wep.reserved */
708 DEBUGFS_FWSTATS_ADD(wep, key_not_found);
709 DEBUGFS_FWSTATS_ADD(wep, decrypt_fail);
710 DEBUGFS_FWSTATS_ADD(wep, packets);
711 DEBUGFS_FWSTATS_ADD(wep, interrupt);
713 DEBUGFS_FWSTATS_ADD(pwr, ps_enter);
714 DEBUGFS_FWSTATS_ADD(pwr, elp_enter);
715 DEBUGFS_FWSTATS_ADD(pwr, missing_bcns);
716 DEBUGFS_FWSTATS_ADD(pwr, wake_on_host);
717 DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp);
718 DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps);
719 DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps);
720 DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons);
721 DEBUGFS_FWSTATS_ADD(pwr, power_save_off);
722 DEBUGFS_FWSTATS_ADD(pwr, enable_ps);
723 DEBUGFS_FWSTATS_ADD(pwr, disable_ps);
724 DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps);
725 /* skipping cont_miss_bcns_spread for now */
726 DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons);
728 DEBUGFS_FWSTATS_ADD(mic, rx_pkts);
729 DEBUGFS_FWSTATS_ADD(mic, calc_failure);
731 DEBUGFS_FWSTATS_ADD(aes, encrypt_fail);
732 DEBUGFS_FWSTATS_ADD(aes, decrypt_fail);
733 DEBUGFS_FWSTATS_ADD(aes, encrypt_packets);
734 DEBUGFS_FWSTATS_ADD(aes, decrypt_packets);
735 DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt);
736 DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt);
738 DEBUGFS_FWSTATS_ADD(event, heart_beat);
739 DEBUGFS_FWSTATS_ADD(event, calibration);
740 DEBUGFS_FWSTATS_ADD(event, rx_mismatch);
741 DEBUGFS_FWSTATS_ADD(event, rx_mem_empty);
742 DEBUGFS_FWSTATS_ADD(event, rx_pool);
743 DEBUGFS_FWSTATS_ADD(event, oom_late);
744 DEBUGFS_FWSTATS_ADD(event, phy_transmit_error);
745 DEBUGFS_FWSTATS_ADD(event, tx_stuck);
747 DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts);
748 DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts);
749 DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime);
750 DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn);
751 DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn);
752 DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization);
753 DEBUGFS_FWSTATS_ADD(ps, upsd_utilization);
755 DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop);
756 DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data);
757 DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data);
758 DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data);
759 DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data);
761 DEBUGFS_ADD(tx_queue_len, rootdir);
762 DEBUGFS_ADD(retry_count, rootdir);
763 DEBUGFS_ADD(excessive_retries, rootdir);
765 DEBUGFS_ADD(gpio_power, rootdir);
766 DEBUGFS_ADD(start_recovery, rootdir);
767 DEBUGFS_ADD(driver_state, rootdir);
768 DEBUGFS_ADD(dtim_interval, rootdir);
769 DEBUGFS_ADD(beacon_interval, rootdir);
771 streaming = debugfs_create_dir("rx_streaming", rootdir);
772 if (!streaming || IS_ERR(streaming))
775 DEBUGFS_ADD_PREFIX(rx_streaming, interval, streaming);
776 DEBUGFS_ADD_PREFIX(rx_streaming, always, streaming);
783 ret = PTR_ERR(entry);
790 void wl1271_debugfs_reset(struct wl1271 *wl)
792 if (!wl->stats.fw_stats)
795 memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
796 wl->stats.retry_count = 0;
797 wl->stats.excessive_retries = 0;
800 int wl1271_debugfs_init(struct wl1271 *wl)
803 struct dentry *rootdir;
805 rootdir = debugfs_create_dir(KBUILD_MODNAME,
806 wl->hw->wiphy->debugfsdir);
808 if (IS_ERR(rootdir)) {
809 ret = PTR_ERR(rootdir);
813 wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats),
816 if (!wl->stats.fw_stats) {
821 wl->stats.fw_stats_update = jiffies;
823 ret = wl1271_debugfs_add_files(wl, rootdir);
831 kfree(wl->stats.fw_stats);
832 wl->stats.fw_stats = NULL;
835 debugfs_remove_recursive(rootdir);
841 void wl1271_debugfs_exit(struct wl1271 *wl)
843 kfree(wl->stats.fw_stats);
844 wl->stats.fw_stats = NULL;