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
;
271 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
273 wl1271_warning("illegal value in gpio_power");
277 mutex_lock(&wl
->mutex
);
282 wl1271_power_off(wl
);
284 mutex_unlock(&wl
->mutex
);
288 static const struct file_operations gpio_power_ops
= {
289 .read
= gpio_power_read
,
290 .write
= gpio_power_write
,
291 .open
= wl1271_open_file_generic
,
292 .llseek
= default_llseek
,
295 static ssize_t
start_recovery_write(struct file
*file
,
296 const char __user
*user_buf
,
297 size_t count
, loff_t
*ppos
)
299 struct wl1271
*wl
= file
->private_data
;
301 mutex_lock(&wl
->mutex
);
302 wl12xx_queue_recovery_work(wl
);
303 mutex_unlock(&wl
->mutex
);
308 static const struct file_operations start_recovery_ops
= {
309 .write
= start_recovery_write
,
310 .open
= wl1271_open_file_generic
,
311 .llseek
= default_llseek
,
314 static ssize_t
driver_state_read(struct file
*file
, char __user
*user_buf
,
315 size_t count
, loff_t
*ppos
)
317 struct wl1271
*wl
= file
->private_data
;
321 mutex_lock(&wl
->mutex
);
323 #define DRIVER_STATE_PRINT(x, fmt) \
324 (res += scnprintf(buf + res, sizeof(buf) - res,\
325 #x " = " fmt "\n", wl->x))
327 #define DRIVER_STATE_PRINT_LONG(x) DRIVER_STATE_PRINT(x, "%ld")
328 #define DRIVER_STATE_PRINT_INT(x) DRIVER_STATE_PRINT(x, "%d")
329 #define DRIVER_STATE_PRINT_STR(x) DRIVER_STATE_PRINT(x, "%s")
330 #define DRIVER_STATE_PRINT_LHEX(x) DRIVER_STATE_PRINT(x, "0x%lx")
331 #define DRIVER_STATE_PRINT_HEX(x) DRIVER_STATE_PRINT(x, "0x%x")
333 DRIVER_STATE_PRINT_INT(tx_blocks_available
);
334 DRIVER_STATE_PRINT_INT(tx_allocated_blocks
);
335 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[0]);
336 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[1]);
337 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[2]);
338 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[3]);
339 DRIVER_STATE_PRINT_INT(tx_frames_cnt
);
340 DRIVER_STATE_PRINT_LHEX(tx_frames_map
[0]);
341 DRIVER_STATE_PRINT_INT(tx_queue_count
[0]);
342 DRIVER_STATE_PRINT_INT(tx_queue_count
[1]);
343 DRIVER_STATE_PRINT_INT(tx_queue_count
[2]);
344 DRIVER_STATE_PRINT_INT(tx_queue_count
[3]);
345 DRIVER_STATE_PRINT_INT(tx_packets_count
);
346 DRIVER_STATE_PRINT_INT(tx_results_count
);
347 DRIVER_STATE_PRINT_LHEX(flags
);
348 DRIVER_STATE_PRINT_INT(tx_blocks_freed
);
349 DRIVER_STATE_PRINT_INT(tx_security_last_seq_lsb
);
350 DRIVER_STATE_PRINT_INT(rx_counter
);
351 DRIVER_STATE_PRINT_INT(state
);
352 DRIVER_STATE_PRINT_INT(channel
);
353 DRIVER_STATE_PRINT_INT(band
);
354 DRIVER_STATE_PRINT_INT(psm_entry_retry
);
355 DRIVER_STATE_PRINT_INT(ps_poll_failures
);
356 DRIVER_STATE_PRINT_INT(power_level
);
357 DRIVER_STATE_PRINT_INT(rssi_thold
);
358 DRIVER_STATE_PRINT_INT(last_rssi_event
);
359 DRIVER_STATE_PRINT_INT(sg_enabled
);
360 DRIVER_STATE_PRINT_INT(enable_11a
);
361 DRIVER_STATE_PRINT_INT(noise
);
362 DRIVER_STATE_PRINT_LHEX(ap_hlid_map
[0]);
363 DRIVER_STATE_PRINT_INT(last_tx_hlid
);
364 DRIVER_STATE_PRINT_INT(ba_support
);
365 DRIVER_STATE_PRINT_HEX(ba_rx_bitmap
);
366 DRIVER_STATE_PRINT_HEX(ap_fw_ps_map
);
367 DRIVER_STATE_PRINT_LHEX(ap_ps_map
);
368 DRIVER_STATE_PRINT_HEX(quirks
);
369 DRIVER_STATE_PRINT_HEX(irq
);
370 DRIVER_STATE_PRINT_HEX(ref_clock
);
371 DRIVER_STATE_PRINT_HEX(tcxo_clock
);
372 DRIVER_STATE_PRINT_HEX(hw_pg_ver
);
373 DRIVER_STATE_PRINT_HEX(platform_quirks
);
374 DRIVER_STATE_PRINT_HEX(chip
.id
);
375 DRIVER_STATE_PRINT_STR(chip
.fw_ver_str
);
376 DRIVER_STATE_PRINT_INT(sched_scanning
);
378 #undef DRIVER_STATE_PRINT_INT
379 #undef DRIVER_STATE_PRINT_LONG
380 #undef DRIVER_STATE_PRINT_HEX
381 #undef DRIVER_STATE_PRINT_LHEX
382 #undef DRIVER_STATE_PRINT_STR
383 #undef DRIVER_STATE_PRINT
385 mutex_unlock(&wl
->mutex
);
387 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, res
);
390 static const struct file_operations driver_state_ops
= {
391 .read
= driver_state_read
,
392 .open
= wl1271_open_file_generic
,
393 .llseek
= default_llseek
,
396 static ssize_t
dtim_interval_read(struct file
*file
, char __user
*user_buf
,
397 size_t count
, loff_t
*ppos
)
399 struct wl1271
*wl
= file
->private_data
;
402 if (wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_DTIM
||
403 wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_N_DTIM
)
404 value
= wl
->conf
.conn
.listen_interval
;
408 return wl1271_format_buffer(user_buf
, count
, ppos
, "%d\n", value
);
411 static ssize_t
dtim_interval_write(struct file
*file
,
412 const char __user
*user_buf
,
413 size_t count
, loff_t
*ppos
)
415 struct wl1271
*wl
= file
->private_data
;
419 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
421 wl1271_warning("illegal value for dtim_interval");
425 if (value
< 1 || value
> 10) {
426 wl1271_warning("dtim value is not in valid range");
430 mutex_lock(&wl
->mutex
);
432 wl
->conf
.conn
.listen_interval
= value
;
433 /* for some reason there are different event types for 1 and >1 */
435 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
;
437 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_N_DTIM
;
440 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
441 * take effect on the next time we enter psm.
443 mutex_unlock(&wl
->mutex
);
447 static const struct file_operations dtim_interval_ops
= {
448 .read
= dtim_interval_read
,
449 .write
= dtim_interval_write
,
450 .open
= wl1271_open_file_generic
,
451 .llseek
= default_llseek
,
454 static ssize_t
beacon_interval_read(struct file
*file
, char __user
*user_buf
,
455 size_t count
, loff_t
*ppos
)
457 struct wl1271
*wl
= file
->private_data
;
460 if (wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_BEACON
||
461 wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_N_BEACONS
)
462 value
= wl
->conf
.conn
.listen_interval
;
466 return wl1271_format_buffer(user_buf
, count
, ppos
, "%d\n", value
);
469 static ssize_t
beacon_interval_write(struct file
*file
,
470 const char __user
*user_buf
,
471 size_t count
, loff_t
*ppos
)
473 struct wl1271
*wl
= file
->private_data
;
477 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
479 wl1271_warning("illegal value for beacon_interval");
483 if (value
< 1 || value
> 255) {
484 wl1271_warning("beacon interval value is not in valid range");
488 mutex_lock(&wl
->mutex
);
490 wl
->conf
.conn
.listen_interval
= value
;
491 /* for some reason there are different event types for 1 and >1 */
493 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_BEACON
;
495 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_N_BEACONS
;
498 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
499 * take effect on the next time we enter psm.
501 mutex_unlock(&wl
->mutex
);
505 static const struct file_operations beacon_interval_ops
= {
506 .read
= beacon_interval_read
,
507 .write
= beacon_interval_write
,
508 .open
= wl1271_open_file_generic
,
509 .llseek
= default_llseek
,
512 static ssize_t
rx_streaming_interval_write(struct file
*file
,
513 const char __user
*user_buf
,
514 size_t count
, loff_t
*ppos
)
516 struct wl1271
*wl
= file
->private_data
;
520 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
522 wl1271_warning("illegal value in rx_streaming_interval!");
526 /* valid values: 0, 10-100 */
527 if (value
&& (value
< 10 || value
> 100)) {
528 wl1271_warning("value is not in range!");
532 mutex_lock(&wl
->mutex
);
534 wl
->conf
.rx_streaming
.interval
= value
;
536 ret
= wl1271_ps_elp_wakeup(wl
);
540 wl1271_recalc_rx_streaming(wl
);
542 wl1271_ps_elp_sleep(wl
);
544 mutex_unlock(&wl
->mutex
);
548 static ssize_t
rx_streaming_interval_read(struct file
*file
,
549 char __user
*userbuf
,
550 size_t count
, loff_t
*ppos
)
552 struct wl1271
*wl
= file
->private_data
;
553 return wl1271_format_buffer(userbuf
, count
, ppos
,
554 "%d\n", wl
->conf
.rx_streaming
.interval
);
557 static const struct file_operations rx_streaming_interval_ops
= {
558 .read
= rx_streaming_interval_read
,
559 .write
= rx_streaming_interval_write
,
560 .open
= wl1271_open_file_generic
,
561 .llseek
= default_llseek
,
564 static ssize_t
rx_streaming_always_write(struct file
*file
,
565 const char __user
*user_buf
,
566 size_t count
, loff_t
*ppos
)
568 struct wl1271
*wl
= file
->private_data
;
572 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
574 wl1271_warning("illegal value in rx_streaming_write!");
578 /* valid values: 0, 10-100 */
579 if (!(value
== 0 || value
== 1)) {
580 wl1271_warning("value is not in valid!");
584 mutex_lock(&wl
->mutex
);
586 wl
->conf
.rx_streaming
.always
= value
;
588 ret
= wl1271_ps_elp_wakeup(wl
);
592 wl1271_recalc_rx_streaming(wl
);
594 wl1271_ps_elp_sleep(wl
);
596 mutex_unlock(&wl
->mutex
);
600 static ssize_t
rx_streaming_always_read(struct file
*file
,
601 char __user
*userbuf
,
602 size_t count
, loff_t
*ppos
)
604 struct wl1271
*wl
= file
->private_data
;
605 return wl1271_format_buffer(userbuf
, count
, ppos
,
606 "%d\n", wl
->conf
.rx_streaming
.always
);
609 static const struct file_operations rx_streaming_always_ops
= {
610 .read
= rx_streaming_always_read
,
611 .write
= rx_streaming_always_write
,
612 .open
= wl1271_open_file_generic
,
613 .llseek
= default_llseek
,
616 static ssize_t
beacon_filtering_write(struct file
*file
,
617 const char __user
*user_buf
,
618 size_t count
, loff_t
*ppos
)
620 struct wl1271
*wl
= file
->private_data
;
621 struct ieee80211_vif
*vif
;
622 struct wl12xx_vif
*wlvif
;
632 wlvif
= wl12xx_vif_to_data(vif
);
634 len
= min(count
, sizeof(buf
) - 1);
635 if (copy_from_user(buf
, user_buf
, len
))
639 ret
= kstrtoul(buf
, 0, &value
);
641 wl1271_warning("illegal value for beacon_filtering!");
645 mutex_lock(&wl
->mutex
);
647 ret
= wl1271_ps_elp_wakeup(wl
);
651 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, !!value
);
653 wl1271_ps_elp_sleep(wl
);
655 mutex_unlock(&wl
->mutex
);
659 static const struct file_operations beacon_filtering_ops
= {
660 .write
= beacon_filtering_write
,
661 .open
= wl1271_open_file_generic
,
662 .llseek
= default_llseek
,
665 static int wl1271_debugfs_add_files(struct wl1271
*wl
,
666 struct dentry
*rootdir
)
669 struct dentry
*entry
, *stats
, *streaming
;
671 stats
= debugfs_create_dir("fw-statistics", rootdir
);
672 if (!stats
|| IS_ERR(stats
)) {
677 DEBUGFS_FWSTATS_ADD(tx
, internal_desc_overflow
);
679 DEBUGFS_FWSTATS_ADD(rx
, out_of_mem
);
680 DEBUGFS_FWSTATS_ADD(rx
, hdr_overflow
);
681 DEBUGFS_FWSTATS_ADD(rx
, hw_stuck
);
682 DEBUGFS_FWSTATS_ADD(rx
, dropped
);
683 DEBUGFS_FWSTATS_ADD(rx
, fcs_err
);
684 DEBUGFS_FWSTATS_ADD(rx
, xfr_hint_trig
);
685 DEBUGFS_FWSTATS_ADD(rx
, path_reset
);
686 DEBUGFS_FWSTATS_ADD(rx
, reset_counter
);
688 DEBUGFS_FWSTATS_ADD(dma
, rx_requested
);
689 DEBUGFS_FWSTATS_ADD(dma
, rx_errors
);
690 DEBUGFS_FWSTATS_ADD(dma
, tx_requested
);
691 DEBUGFS_FWSTATS_ADD(dma
, tx_errors
);
693 DEBUGFS_FWSTATS_ADD(isr
, cmd_cmplt
);
694 DEBUGFS_FWSTATS_ADD(isr
, fiqs
);
695 DEBUGFS_FWSTATS_ADD(isr
, rx_headers
);
696 DEBUGFS_FWSTATS_ADD(isr
, rx_mem_overflow
);
697 DEBUGFS_FWSTATS_ADD(isr
, rx_rdys
);
698 DEBUGFS_FWSTATS_ADD(isr
, irqs
);
699 DEBUGFS_FWSTATS_ADD(isr
, tx_procs
);
700 DEBUGFS_FWSTATS_ADD(isr
, decrypt_done
);
701 DEBUGFS_FWSTATS_ADD(isr
, dma0_done
);
702 DEBUGFS_FWSTATS_ADD(isr
, dma1_done
);
703 DEBUGFS_FWSTATS_ADD(isr
, tx_exch_complete
);
704 DEBUGFS_FWSTATS_ADD(isr
, commands
);
705 DEBUGFS_FWSTATS_ADD(isr
, rx_procs
);
706 DEBUGFS_FWSTATS_ADD(isr
, hw_pm_mode_changes
);
707 DEBUGFS_FWSTATS_ADD(isr
, host_acknowledges
);
708 DEBUGFS_FWSTATS_ADD(isr
, pci_pm
);
709 DEBUGFS_FWSTATS_ADD(isr
, wakeups
);
710 DEBUGFS_FWSTATS_ADD(isr
, low_rssi
);
712 DEBUGFS_FWSTATS_ADD(wep
, addr_key_count
);
713 DEBUGFS_FWSTATS_ADD(wep
, default_key_count
);
714 /* skipping wep.reserved */
715 DEBUGFS_FWSTATS_ADD(wep
, key_not_found
);
716 DEBUGFS_FWSTATS_ADD(wep
, decrypt_fail
);
717 DEBUGFS_FWSTATS_ADD(wep
, packets
);
718 DEBUGFS_FWSTATS_ADD(wep
, interrupt
);
720 DEBUGFS_FWSTATS_ADD(pwr
, ps_enter
);
721 DEBUGFS_FWSTATS_ADD(pwr
, elp_enter
);
722 DEBUGFS_FWSTATS_ADD(pwr
, missing_bcns
);
723 DEBUGFS_FWSTATS_ADD(pwr
, wake_on_host
);
724 DEBUGFS_FWSTATS_ADD(pwr
, wake_on_timer_exp
);
725 DEBUGFS_FWSTATS_ADD(pwr
, tx_with_ps
);
726 DEBUGFS_FWSTATS_ADD(pwr
, tx_without_ps
);
727 DEBUGFS_FWSTATS_ADD(pwr
, rcvd_beacons
);
728 DEBUGFS_FWSTATS_ADD(pwr
, power_save_off
);
729 DEBUGFS_FWSTATS_ADD(pwr
, enable_ps
);
730 DEBUGFS_FWSTATS_ADD(pwr
, disable_ps
);
731 DEBUGFS_FWSTATS_ADD(pwr
, fix_tsf_ps
);
732 /* skipping cont_miss_bcns_spread for now */
733 DEBUGFS_FWSTATS_ADD(pwr
, rcvd_awake_beacons
);
735 DEBUGFS_FWSTATS_ADD(mic
, rx_pkts
);
736 DEBUGFS_FWSTATS_ADD(mic
, calc_failure
);
738 DEBUGFS_FWSTATS_ADD(aes
, encrypt_fail
);
739 DEBUGFS_FWSTATS_ADD(aes
, decrypt_fail
);
740 DEBUGFS_FWSTATS_ADD(aes
, encrypt_packets
);
741 DEBUGFS_FWSTATS_ADD(aes
, decrypt_packets
);
742 DEBUGFS_FWSTATS_ADD(aes
, encrypt_interrupt
);
743 DEBUGFS_FWSTATS_ADD(aes
, decrypt_interrupt
);
745 DEBUGFS_FWSTATS_ADD(event
, heart_beat
);
746 DEBUGFS_FWSTATS_ADD(event
, calibration
);
747 DEBUGFS_FWSTATS_ADD(event
, rx_mismatch
);
748 DEBUGFS_FWSTATS_ADD(event
, rx_mem_empty
);
749 DEBUGFS_FWSTATS_ADD(event
, rx_pool
);
750 DEBUGFS_FWSTATS_ADD(event
, oom_late
);
751 DEBUGFS_FWSTATS_ADD(event
, phy_transmit_error
);
752 DEBUGFS_FWSTATS_ADD(event
, tx_stuck
);
754 DEBUGFS_FWSTATS_ADD(ps
, pspoll_timeouts
);
755 DEBUGFS_FWSTATS_ADD(ps
, upsd_timeouts
);
756 DEBUGFS_FWSTATS_ADD(ps
, upsd_max_sptime
);
757 DEBUGFS_FWSTATS_ADD(ps
, upsd_max_apturn
);
758 DEBUGFS_FWSTATS_ADD(ps
, pspoll_max_apturn
);
759 DEBUGFS_FWSTATS_ADD(ps
, pspoll_utilization
);
760 DEBUGFS_FWSTATS_ADD(ps
, upsd_utilization
);
762 DEBUGFS_FWSTATS_ADD(rxpipe
, rx_prep_beacon_drop
);
763 DEBUGFS_FWSTATS_ADD(rxpipe
, descr_host_int_trig_rx_data
);
764 DEBUGFS_FWSTATS_ADD(rxpipe
, beacon_buffer_thres_host_int_trig_rx_data
);
765 DEBUGFS_FWSTATS_ADD(rxpipe
, missed_beacon_host_int_trig_rx_data
);
766 DEBUGFS_FWSTATS_ADD(rxpipe
, tx_xfr_host_int_trig_rx_data
);
768 DEBUGFS_ADD(tx_queue_len
, rootdir
);
769 DEBUGFS_ADD(retry_count
, rootdir
);
770 DEBUGFS_ADD(excessive_retries
, rootdir
);
772 DEBUGFS_ADD(gpio_power
, rootdir
);
773 DEBUGFS_ADD(start_recovery
, rootdir
);
774 DEBUGFS_ADD(driver_state
, rootdir
);
775 DEBUGFS_ADD(dtim_interval
, rootdir
);
776 DEBUGFS_ADD(beacon_interval
, rootdir
);
777 DEBUGFS_ADD(beacon_filtering
, rootdir
);
779 streaming
= debugfs_create_dir("rx_streaming", rootdir
);
780 if (!streaming
|| IS_ERR(streaming
))
783 DEBUGFS_ADD_PREFIX(rx_streaming
, interval
, streaming
);
784 DEBUGFS_ADD_PREFIX(rx_streaming
, always
, streaming
);
791 ret
= PTR_ERR(entry
);
798 void wl1271_debugfs_reset(struct wl1271
*wl
)
800 if (!wl
->stats
.fw_stats
)
803 memset(wl
->stats
.fw_stats
, 0, sizeof(*wl
->stats
.fw_stats
));
804 wl
->stats
.retry_count
= 0;
805 wl
->stats
.excessive_retries
= 0;
808 int wl1271_debugfs_init(struct wl1271
*wl
)
811 struct dentry
*rootdir
;
813 rootdir
= debugfs_create_dir(KBUILD_MODNAME
,
814 wl
->hw
->wiphy
->debugfsdir
);
816 if (IS_ERR(rootdir
)) {
817 ret
= PTR_ERR(rootdir
);
821 wl
->stats
.fw_stats
= kzalloc(sizeof(*wl
->stats
.fw_stats
),
824 if (!wl
->stats
.fw_stats
) {
829 wl
->stats
.fw_stats_update
= jiffies
;
831 ret
= wl1271_debugfs_add_files(wl
, rootdir
);
839 kfree(wl
->stats
.fw_stats
);
840 wl
->stats
.fw_stats
= NULL
;
843 debugfs_remove_recursive(rootdir
);
849 void wl1271_debugfs_exit(struct wl1271
*wl
)
851 kfree(wl
->stats
.fw_stats
);
852 wl
->stats
.fw_stats
= NULL
;