1 // SPDX-License-Identifier: GPL-2.0-only
3 * This file is part of wl1271
5 * Copyright (C) 2009 Nokia Corporation
7 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
12 #include <linux/skbuff.h>
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/pm_runtime.h>
26 #define WL1271_DEBUGFS_STATS_LIFETIME 1000
28 #define WLCORE_MAX_BLOCK_SIZE ((size_t)(4*PAGE_SIZE))
30 /* debugfs macros idea from mac80211 */
31 int wl1271_format_buffer(char __user
*userbuf
, size_t count
,
32 loff_t
*ppos
, char *fmt
, ...)
35 char buf
[DEBUGFS_FORMAT_BUFFER_SIZE
];
39 res
= vscnprintf(buf
, sizeof(buf
), fmt
, args
);
42 return simple_read_from_buffer(userbuf
, count
, ppos
, buf
, res
);
44 EXPORT_SYMBOL_GPL(wl1271_format_buffer
);
46 void wl1271_debugfs_update_stats(struct wl1271
*wl
)
50 mutex_lock(&wl
->mutex
);
52 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
55 ret
= pm_runtime_get_sync(wl
->dev
);
57 pm_runtime_put_noidle(wl
->dev
);
62 time_after(jiffies
, wl
->stats
.fw_stats_update
+
63 msecs_to_jiffies(WL1271_DEBUGFS_STATS_LIFETIME
))) {
64 wl1271_acx_statistics(wl
, wl
->stats
.fw_stats
);
65 wl
->stats
.fw_stats_update
= jiffies
;
68 pm_runtime_mark_last_busy(wl
->dev
);
69 pm_runtime_put_autosuspend(wl
->dev
);
72 mutex_unlock(&wl
->mutex
);
74 EXPORT_SYMBOL_GPL(wl1271_debugfs_update_stats
);
76 DEBUGFS_READONLY_FILE(retry_count
, "%u", wl
->stats
.retry_count
);
77 DEBUGFS_READONLY_FILE(excessive_retries
, "%u",
78 wl
->stats
.excessive_retries
);
80 static ssize_t
tx_queue_len_read(struct file
*file
, char __user
*userbuf
,
81 size_t count
, loff_t
*ppos
)
83 struct wl1271
*wl
= file
->private_data
;
88 queue_len
= wl1271_tx_total_queue_count(wl
);
90 res
= scnprintf(buf
, sizeof(buf
), "%u\n", queue_len
);
91 return simple_read_from_buffer(userbuf
, count
, ppos
, buf
, res
);
94 static const struct file_operations tx_queue_len_ops
= {
95 .read
= tx_queue_len_read
,
97 .llseek
= default_llseek
,
100 static void chip_op_handler(struct wl1271
*wl
, unsigned long value
,
104 int (*chip_op
) (struct wl1271
*wl
);
107 wl1271_warning("debugfs chip_op_handler with no callback");
111 ret
= pm_runtime_get_sync(wl
->dev
);
113 pm_runtime_put_noidle(wl
->dev
);
121 pm_runtime_mark_last_busy(wl
->dev
);
122 pm_runtime_put_autosuspend(wl
->dev
);
125 #define WL12XX_CONF_DEBUGFS(param, conf_sub_struct, \
126 min_val, max_val, write_handler_locked, \
128 static ssize_t param##_read(struct file *file, \
129 char __user *user_buf, \
130 size_t count, loff_t *ppos) \
132 struct wl1271 *wl = file->private_data; \
133 return wl1271_format_buffer(user_buf, count, \
135 wl->conf.conf_sub_struct.param); \
138 static ssize_t param##_write(struct file *file, \
139 const char __user *user_buf, \
140 size_t count, loff_t *ppos) \
142 struct wl1271 *wl = file->private_data; \
143 unsigned long value; \
146 ret = kstrtoul_from_user(user_buf, count, 10, &value); \
148 wl1271_warning("illegal value for " #param); \
152 if (value < min_val || value > max_val) { \
153 wl1271_warning(#param " is not in valid range"); \
157 mutex_lock(&wl->mutex); \
158 wl->conf.conf_sub_struct.param = value; \
160 write_handler_locked(wl, value, write_handler_arg); \
162 mutex_unlock(&wl->mutex); \
166 static const struct file_operations param##_ops = { \
167 .read = param##_read, \
168 .write = param##_write, \
169 .open = simple_open, \
170 .llseek = default_llseek, \
173 WL12XX_CONF_DEBUGFS(irq_pkt_threshold
, rx
, 0, 65535,
174 chip_op_handler
, wl1271_acx_init_rx_interrupt
)
175 WL12XX_CONF_DEBUGFS(irq_blk_threshold
, rx
, 0, 65535,
176 chip_op_handler
, wl1271_acx_init_rx_interrupt
)
177 WL12XX_CONF_DEBUGFS(irq_timeout
, rx
, 0, 100,
178 chip_op_handler
, wl1271_acx_init_rx_interrupt
)
180 static ssize_t
gpio_power_read(struct file
*file
, char __user
*user_buf
,
181 size_t count
, loff_t
*ppos
)
183 struct wl1271
*wl
= file
->private_data
;
184 bool state
= test_bit(WL1271_FLAG_GPIO_POWER
, &wl
->flags
);
189 res
= scnprintf(buf
, sizeof(buf
), "%d\n", state
);
191 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, res
);
194 static ssize_t
gpio_power_write(struct file
*file
,
195 const char __user
*user_buf
,
196 size_t count
, loff_t
*ppos
)
198 struct wl1271
*wl
= file
->private_data
;
202 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
204 wl1271_warning("illegal value in gpio_power");
208 mutex_lock(&wl
->mutex
);
213 wl1271_power_off(wl
);
215 mutex_unlock(&wl
->mutex
);
219 static const struct file_operations gpio_power_ops
= {
220 .read
= gpio_power_read
,
221 .write
= gpio_power_write
,
223 .llseek
= default_llseek
,
226 static ssize_t
start_recovery_write(struct file
*file
,
227 const char __user
*user_buf
,
228 size_t count
, loff_t
*ppos
)
230 struct wl1271
*wl
= file
->private_data
;
232 mutex_lock(&wl
->mutex
);
233 wl12xx_queue_recovery_work(wl
);
234 mutex_unlock(&wl
->mutex
);
239 static const struct file_operations start_recovery_ops
= {
240 .write
= start_recovery_write
,
242 .llseek
= default_llseek
,
245 static ssize_t
dynamic_ps_timeout_read(struct file
*file
, char __user
*user_buf
,
246 size_t count
, loff_t
*ppos
)
248 struct wl1271
*wl
= file
->private_data
;
250 return wl1271_format_buffer(user_buf
, count
,
252 wl
->conf
.conn
.dynamic_ps_timeout
);
255 static ssize_t
dynamic_ps_timeout_write(struct file
*file
,
256 const char __user
*user_buf
,
257 size_t count
, loff_t
*ppos
)
259 struct wl1271
*wl
= file
->private_data
;
260 struct wl12xx_vif
*wlvif
;
264 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
266 wl1271_warning("illegal value in dynamic_ps");
270 if (value
< 1 || value
> 65535) {
271 wl1271_warning("dynamic_ps_timeout is not in valid range");
275 mutex_lock(&wl
->mutex
);
277 wl
->conf
.conn
.dynamic_ps_timeout
= value
;
279 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
282 ret
= pm_runtime_get_sync(wl
->dev
);
284 pm_runtime_put_noidle(wl
->dev
);
288 /* In case we're already in PSM, trigger it again to set new timeout
289 * immediately without waiting for re-association
292 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
293 if (test_bit(WLVIF_FLAG_IN_PS
, &wlvif
->flags
))
294 wl1271_ps_set_mode(wl
, wlvif
, STATION_AUTO_PS_MODE
);
297 pm_runtime_mark_last_busy(wl
->dev
);
298 pm_runtime_put_autosuspend(wl
->dev
);
301 mutex_unlock(&wl
->mutex
);
305 static const struct file_operations dynamic_ps_timeout_ops
= {
306 .read
= dynamic_ps_timeout_read
,
307 .write
= dynamic_ps_timeout_write
,
309 .llseek
= default_llseek
,
312 static ssize_t
forced_ps_read(struct file
*file
, char __user
*user_buf
,
313 size_t count
, loff_t
*ppos
)
315 struct wl1271
*wl
= file
->private_data
;
317 return wl1271_format_buffer(user_buf
, count
,
319 wl
->conf
.conn
.forced_ps
);
322 static ssize_t
forced_ps_write(struct file
*file
,
323 const char __user
*user_buf
,
324 size_t count
, loff_t
*ppos
)
326 struct wl1271
*wl
= file
->private_data
;
327 struct wl12xx_vif
*wlvif
;
331 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
333 wl1271_warning("illegal value in forced_ps");
337 if (value
!= 1 && value
!= 0) {
338 wl1271_warning("forced_ps should be either 0 or 1");
342 mutex_lock(&wl
->mutex
);
344 if (wl
->conf
.conn
.forced_ps
== value
)
347 wl
->conf
.conn
.forced_ps
= value
;
349 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
352 ret
= pm_runtime_get_sync(wl
->dev
);
354 pm_runtime_put_noidle(wl
->dev
);
358 /* In case we're already in PSM, trigger it again to switch mode
359 * immediately without waiting for re-association
362 ps_mode
= value
? STATION_POWER_SAVE_MODE
: STATION_AUTO_PS_MODE
;
364 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
365 if (test_bit(WLVIF_FLAG_IN_PS
, &wlvif
->flags
))
366 wl1271_ps_set_mode(wl
, wlvif
, ps_mode
);
369 pm_runtime_mark_last_busy(wl
->dev
);
370 pm_runtime_put_autosuspend(wl
->dev
);
373 mutex_unlock(&wl
->mutex
);
377 static const struct file_operations forced_ps_ops
= {
378 .read
= forced_ps_read
,
379 .write
= forced_ps_write
,
381 .llseek
= default_llseek
,
384 static ssize_t
split_scan_timeout_read(struct file
*file
, char __user
*user_buf
,
385 size_t count
, loff_t
*ppos
)
387 struct wl1271
*wl
= file
->private_data
;
389 return wl1271_format_buffer(user_buf
, count
,
391 wl
->conf
.scan
.split_scan_timeout
/ 1000);
394 static ssize_t
split_scan_timeout_write(struct file
*file
,
395 const char __user
*user_buf
,
396 size_t count
, loff_t
*ppos
)
398 struct wl1271
*wl
= file
->private_data
;
402 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
404 wl1271_warning("illegal value in split_scan_timeout");
409 wl1271_info("split scan will be disabled");
411 mutex_lock(&wl
->mutex
);
413 wl
->conf
.scan
.split_scan_timeout
= value
* 1000;
415 mutex_unlock(&wl
->mutex
);
419 static const struct file_operations split_scan_timeout_ops
= {
420 .read
= split_scan_timeout_read
,
421 .write
= split_scan_timeout_write
,
423 .llseek
= default_llseek
,
426 static ssize_t
driver_state_read(struct file
*file
, char __user
*user_buf
,
427 size_t count
, loff_t
*ppos
)
429 struct wl1271
*wl
= file
->private_data
;
433 struct wl12xx_vif
*wlvif
;
435 #define DRIVER_STATE_BUF_LEN 1024
437 buf
= kmalloc(DRIVER_STATE_BUF_LEN
, GFP_KERNEL
);
441 mutex_lock(&wl
->mutex
);
443 #define DRIVER_STATE_PRINT(x, fmt) \
444 (res += scnprintf(buf + res, DRIVER_STATE_BUF_LEN - res,\
445 #x " = " fmt "\n", wl->x))
447 #define DRIVER_STATE_PRINT_GENERIC(x, fmt, args...) \
448 (res += scnprintf(buf + res, DRIVER_STATE_BUF_LEN - res,\
449 #x " = " fmt "\n", args))
451 #define DRIVER_STATE_PRINT_LONG(x) DRIVER_STATE_PRINT(x, "%ld")
452 #define DRIVER_STATE_PRINT_INT(x) DRIVER_STATE_PRINT(x, "%d")
453 #define DRIVER_STATE_PRINT_STR(x) DRIVER_STATE_PRINT(x, "%s")
454 #define DRIVER_STATE_PRINT_LHEX(x) DRIVER_STATE_PRINT(x, "0x%lx")
455 #define DRIVER_STATE_PRINT_HEX(x) DRIVER_STATE_PRINT(x, "0x%x")
457 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
458 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
461 DRIVER_STATE_PRINT_GENERIC(channel
, "%d (%s)", wlvif
->channel
,
462 wlvif
->p2p
? "P2P-CL" : "STA");
465 wl12xx_for_each_wlvif_ap(wl
, wlvif
)
466 DRIVER_STATE_PRINT_GENERIC(channel
, "%d (%s)", wlvif
->channel
,
467 wlvif
->p2p
? "P2P-GO" : "AP");
469 DRIVER_STATE_PRINT_INT(tx_blocks_available
);
470 DRIVER_STATE_PRINT_INT(tx_allocated_blocks
);
471 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[0]);
472 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[1]);
473 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[2]);
474 DRIVER_STATE_PRINT_INT(tx_allocated_pkts
[3]);
475 DRIVER_STATE_PRINT_INT(tx_frames_cnt
);
476 DRIVER_STATE_PRINT_LHEX(tx_frames_map
[0]);
477 DRIVER_STATE_PRINT_INT(tx_queue_count
[0]);
478 DRIVER_STATE_PRINT_INT(tx_queue_count
[1]);
479 DRIVER_STATE_PRINT_INT(tx_queue_count
[2]);
480 DRIVER_STATE_PRINT_INT(tx_queue_count
[3]);
481 DRIVER_STATE_PRINT_INT(tx_packets_count
);
482 DRIVER_STATE_PRINT_INT(tx_results_count
);
483 DRIVER_STATE_PRINT_LHEX(flags
);
484 DRIVER_STATE_PRINT_INT(tx_blocks_freed
);
485 DRIVER_STATE_PRINT_INT(rx_counter
);
486 DRIVER_STATE_PRINT_INT(state
);
487 DRIVER_STATE_PRINT_INT(band
);
488 DRIVER_STATE_PRINT_INT(power_level
);
489 DRIVER_STATE_PRINT_INT(sg_enabled
);
490 DRIVER_STATE_PRINT_INT(enable_11a
);
491 DRIVER_STATE_PRINT_INT(noise
);
492 DRIVER_STATE_PRINT_LHEX(ap_fw_ps_map
);
493 DRIVER_STATE_PRINT_LHEX(ap_ps_map
);
494 DRIVER_STATE_PRINT_HEX(quirks
);
495 DRIVER_STATE_PRINT_HEX(irq
);
496 /* TODO: ref_clock and tcxo_clock were moved to wl12xx priv */
497 DRIVER_STATE_PRINT_HEX(hw_pg_ver
);
498 DRIVER_STATE_PRINT_HEX(irq_flags
);
499 DRIVER_STATE_PRINT_HEX(chip
.id
);
500 DRIVER_STATE_PRINT_STR(chip
.fw_ver_str
);
501 DRIVER_STATE_PRINT_STR(chip
.phy_fw_ver_str
);
502 DRIVER_STATE_PRINT_INT(recovery_count
);
504 #undef DRIVER_STATE_PRINT_INT
505 #undef DRIVER_STATE_PRINT_LONG
506 #undef DRIVER_STATE_PRINT_HEX
507 #undef DRIVER_STATE_PRINT_LHEX
508 #undef DRIVER_STATE_PRINT_STR
509 #undef DRIVER_STATE_PRINT
510 #undef DRIVER_STATE_BUF_LEN
512 mutex_unlock(&wl
->mutex
);
514 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, res
);
519 static const struct file_operations driver_state_ops
= {
520 .read
= driver_state_read
,
522 .llseek
= default_llseek
,
525 static ssize_t
vifs_state_read(struct file
*file
, char __user
*user_buf
,
526 size_t count
, loff_t
*ppos
)
528 struct wl1271
*wl
= file
->private_data
;
529 struct wl12xx_vif
*wlvif
;
531 const int buf_size
= 4096;
535 buf
= kzalloc(buf_size
, GFP_KERNEL
);
539 mutex_lock(&wl
->mutex
);
541 #define VIF_STATE_PRINT(x, fmt) \
542 (res += scnprintf(buf + res, buf_size - res, \
543 #x " = " fmt "\n", wlvif->x))
545 #define VIF_STATE_PRINT_LONG(x) VIF_STATE_PRINT(x, "%ld")
546 #define VIF_STATE_PRINT_INT(x) VIF_STATE_PRINT(x, "%d")
547 #define VIF_STATE_PRINT_STR(x) VIF_STATE_PRINT(x, "%s")
548 #define VIF_STATE_PRINT_LHEX(x) VIF_STATE_PRINT(x, "0x%lx")
549 #define VIF_STATE_PRINT_LLHEX(x) VIF_STATE_PRINT(x, "0x%llx")
550 #define VIF_STATE_PRINT_HEX(x) VIF_STATE_PRINT(x, "0x%x")
552 #define VIF_STATE_PRINT_NSTR(x, len) \
554 memset(tmp_buf, 0, sizeof(tmp_buf)); \
555 memcpy(tmp_buf, wlvif->x, \
556 min_t(u8, len, sizeof(tmp_buf) - 1)); \
557 res += scnprintf(buf + res, buf_size - res, \
558 #x " = %s\n", tmp_buf); \
561 wl12xx_for_each_wlvif(wl
, wlvif
) {
562 VIF_STATE_PRINT_INT(role_id
);
563 VIF_STATE_PRINT_INT(bss_type
);
564 VIF_STATE_PRINT_LHEX(flags
);
565 VIF_STATE_PRINT_INT(p2p
);
566 VIF_STATE_PRINT_INT(dev_role_id
);
567 VIF_STATE_PRINT_INT(dev_hlid
);
569 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
570 wlvif
->bss_type
== BSS_TYPE_IBSS
) {
571 VIF_STATE_PRINT_INT(sta
.hlid
);
572 VIF_STATE_PRINT_INT(sta
.basic_rate_idx
);
573 VIF_STATE_PRINT_INT(sta
.ap_rate_idx
);
574 VIF_STATE_PRINT_INT(sta
.p2p_rate_idx
);
575 VIF_STATE_PRINT_INT(sta
.qos
);
577 VIF_STATE_PRINT_INT(ap
.global_hlid
);
578 VIF_STATE_PRINT_INT(ap
.bcast_hlid
);
579 VIF_STATE_PRINT_LHEX(ap
.sta_hlid_map
[0]);
580 VIF_STATE_PRINT_INT(ap
.mgmt_rate_idx
);
581 VIF_STATE_PRINT_INT(ap
.bcast_rate_idx
);
582 VIF_STATE_PRINT_INT(ap
.ucast_rate_idx
[0]);
583 VIF_STATE_PRINT_INT(ap
.ucast_rate_idx
[1]);
584 VIF_STATE_PRINT_INT(ap
.ucast_rate_idx
[2]);
585 VIF_STATE_PRINT_INT(ap
.ucast_rate_idx
[3]);
587 VIF_STATE_PRINT_INT(last_tx_hlid
);
588 VIF_STATE_PRINT_INT(tx_queue_count
[0]);
589 VIF_STATE_PRINT_INT(tx_queue_count
[1]);
590 VIF_STATE_PRINT_INT(tx_queue_count
[2]);
591 VIF_STATE_PRINT_INT(tx_queue_count
[3]);
592 VIF_STATE_PRINT_LHEX(links_map
[0]);
593 VIF_STATE_PRINT_NSTR(ssid
, wlvif
->ssid_len
);
594 VIF_STATE_PRINT_INT(band
);
595 VIF_STATE_PRINT_INT(channel
);
596 VIF_STATE_PRINT_HEX(bitrate_masks
[0]);
597 VIF_STATE_PRINT_HEX(bitrate_masks
[1]);
598 VIF_STATE_PRINT_HEX(basic_rate_set
);
599 VIF_STATE_PRINT_HEX(basic_rate
);
600 VIF_STATE_PRINT_HEX(rate_set
);
601 VIF_STATE_PRINT_INT(beacon_int
);
602 VIF_STATE_PRINT_INT(default_key
);
603 VIF_STATE_PRINT_INT(aid
);
604 VIF_STATE_PRINT_INT(psm_entry_retry
);
605 VIF_STATE_PRINT_INT(power_level
);
606 VIF_STATE_PRINT_INT(rssi_thold
);
607 VIF_STATE_PRINT_INT(last_rssi_event
);
608 VIF_STATE_PRINT_INT(ba_support
);
609 VIF_STATE_PRINT_INT(ba_allowed
);
610 VIF_STATE_PRINT_LLHEX(total_freed_pkts
);
613 #undef VIF_STATE_PRINT_INT
614 #undef VIF_STATE_PRINT_LONG
615 #undef VIF_STATE_PRINT_HEX
616 #undef VIF_STATE_PRINT_LHEX
617 #undef VIF_STATE_PRINT_LLHEX
618 #undef VIF_STATE_PRINT_STR
619 #undef VIF_STATE_PRINT_NSTR
620 #undef VIF_STATE_PRINT
622 mutex_unlock(&wl
->mutex
);
624 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, res
);
629 static const struct file_operations vifs_state_ops
= {
630 .read
= vifs_state_read
,
632 .llseek
= default_llseek
,
635 static ssize_t
dtim_interval_read(struct file
*file
, char __user
*user_buf
,
636 size_t count
, loff_t
*ppos
)
638 struct wl1271
*wl
= file
->private_data
;
641 if (wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_DTIM
||
642 wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_N_DTIM
)
643 value
= wl
->conf
.conn
.listen_interval
;
647 return wl1271_format_buffer(user_buf
, count
, ppos
, "%d\n", value
);
650 static ssize_t
dtim_interval_write(struct file
*file
,
651 const char __user
*user_buf
,
652 size_t count
, loff_t
*ppos
)
654 struct wl1271
*wl
= file
->private_data
;
658 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
660 wl1271_warning("illegal value for dtim_interval");
664 if (value
< 1 || value
> 10) {
665 wl1271_warning("dtim value is not in valid range");
669 mutex_lock(&wl
->mutex
);
671 wl
->conf
.conn
.listen_interval
= value
;
672 /* for some reason there are different event types for 1 and >1 */
674 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
;
676 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_N_DTIM
;
679 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
680 * take effect on the next time we enter psm.
682 mutex_unlock(&wl
->mutex
);
686 static const struct file_operations dtim_interval_ops
= {
687 .read
= dtim_interval_read
,
688 .write
= dtim_interval_write
,
690 .llseek
= default_llseek
,
695 static ssize_t
suspend_dtim_interval_read(struct file
*file
,
696 char __user
*user_buf
,
697 size_t count
, loff_t
*ppos
)
699 struct wl1271
*wl
= file
->private_data
;
702 if (wl
->conf
.conn
.suspend_wake_up_event
== CONF_WAKE_UP_EVENT_DTIM
||
703 wl
->conf
.conn
.suspend_wake_up_event
== CONF_WAKE_UP_EVENT_N_DTIM
)
704 value
= wl
->conf
.conn
.suspend_listen_interval
;
708 return wl1271_format_buffer(user_buf
, count
, ppos
, "%d\n", value
);
711 static ssize_t
suspend_dtim_interval_write(struct file
*file
,
712 const char __user
*user_buf
,
713 size_t count
, loff_t
*ppos
)
715 struct wl1271
*wl
= file
->private_data
;
719 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
721 wl1271_warning("illegal value for suspend_dtim_interval");
725 if (value
< 1 || value
> 10) {
726 wl1271_warning("suspend_dtim value is not in valid range");
730 mutex_lock(&wl
->mutex
);
732 wl
->conf
.conn
.suspend_listen_interval
= value
;
733 /* for some reason there are different event types for 1 and >1 */
735 wl
->conf
.conn
.suspend_wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
;
737 wl
->conf
.conn
.suspend_wake_up_event
= CONF_WAKE_UP_EVENT_N_DTIM
;
739 mutex_unlock(&wl
->mutex
);
744 static const struct file_operations suspend_dtim_interval_ops
= {
745 .read
= suspend_dtim_interval_read
,
746 .write
= suspend_dtim_interval_write
,
748 .llseek
= default_llseek
,
751 static ssize_t
beacon_interval_read(struct file
*file
, char __user
*user_buf
,
752 size_t count
, loff_t
*ppos
)
754 struct wl1271
*wl
= file
->private_data
;
757 if (wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_BEACON
||
758 wl
->conf
.conn
.wake_up_event
== CONF_WAKE_UP_EVENT_N_BEACONS
)
759 value
= wl
->conf
.conn
.listen_interval
;
763 return wl1271_format_buffer(user_buf
, count
, ppos
, "%d\n", value
);
766 static ssize_t
beacon_interval_write(struct file
*file
,
767 const char __user
*user_buf
,
768 size_t count
, loff_t
*ppos
)
770 struct wl1271
*wl
= file
->private_data
;
774 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
776 wl1271_warning("illegal value for beacon_interval");
780 if (value
< 1 || value
> 255) {
781 wl1271_warning("beacon interval value is not in valid range");
785 mutex_lock(&wl
->mutex
);
787 wl
->conf
.conn
.listen_interval
= value
;
788 /* for some reason there are different event types for 1 and >1 */
790 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_BEACON
;
792 wl
->conf
.conn
.wake_up_event
= CONF_WAKE_UP_EVENT_N_BEACONS
;
795 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
796 * take effect on the next time we enter psm.
798 mutex_unlock(&wl
->mutex
);
802 static const struct file_operations beacon_interval_ops
= {
803 .read
= beacon_interval_read
,
804 .write
= beacon_interval_write
,
806 .llseek
= default_llseek
,
809 static ssize_t
rx_streaming_interval_write(struct file
*file
,
810 const char __user
*user_buf
,
811 size_t count
, loff_t
*ppos
)
813 struct wl1271
*wl
= file
->private_data
;
814 struct wl12xx_vif
*wlvif
;
818 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
820 wl1271_warning("illegal value in rx_streaming_interval!");
824 /* valid values: 0, 10-100 */
825 if (value
&& (value
< 10 || value
> 100)) {
826 wl1271_warning("value is not in range!");
830 mutex_lock(&wl
->mutex
);
832 wl
->conf
.rx_streaming
.interval
= value
;
834 ret
= pm_runtime_get_sync(wl
->dev
);
836 pm_runtime_put_noidle(wl
->dev
);
840 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
841 wl1271_recalc_rx_streaming(wl
, wlvif
);
844 pm_runtime_mark_last_busy(wl
->dev
);
845 pm_runtime_put_autosuspend(wl
->dev
);
847 mutex_unlock(&wl
->mutex
);
851 static ssize_t
rx_streaming_interval_read(struct file
*file
,
852 char __user
*userbuf
,
853 size_t count
, loff_t
*ppos
)
855 struct wl1271
*wl
= file
->private_data
;
856 return wl1271_format_buffer(userbuf
, count
, ppos
,
857 "%d\n", wl
->conf
.rx_streaming
.interval
);
860 static const struct file_operations rx_streaming_interval_ops
= {
861 .read
= rx_streaming_interval_read
,
862 .write
= rx_streaming_interval_write
,
864 .llseek
= default_llseek
,
867 static ssize_t
rx_streaming_always_write(struct file
*file
,
868 const char __user
*user_buf
,
869 size_t count
, loff_t
*ppos
)
871 struct wl1271
*wl
= file
->private_data
;
872 struct wl12xx_vif
*wlvif
;
876 ret
= kstrtoul_from_user(user_buf
, count
, 10, &value
);
878 wl1271_warning("illegal value in rx_streaming_write!");
882 /* valid values: 0, 10-100 */
883 if (!(value
== 0 || value
== 1)) {
884 wl1271_warning("value is not in valid!");
888 mutex_lock(&wl
->mutex
);
890 wl
->conf
.rx_streaming
.always
= value
;
892 ret
= pm_runtime_get_sync(wl
->dev
);
894 pm_runtime_put_noidle(wl
->dev
);
898 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
899 wl1271_recalc_rx_streaming(wl
, wlvif
);
902 pm_runtime_mark_last_busy(wl
->dev
);
903 pm_runtime_put_autosuspend(wl
->dev
);
905 mutex_unlock(&wl
->mutex
);
909 static ssize_t
rx_streaming_always_read(struct file
*file
,
910 char __user
*userbuf
,
911 size_t count
, loff_t
*ppos
)
913 struct wl1271
*wl
= file
->private_data
;
914 return wl1271_format_buffer(userbuf
, count
, ppos
,
915 "%d\n", wl
->conf
.rx_streaming
.always
);
918 static const struct file_operations rx_streaming_always_ops
= {
919 .read
= rx_streaming_always_read
,
920 .write
= rx_streaming_always_write
,
922 .llseek
= default_llseek
,
925 static ssize_t
beacon_filtering_write(struct file
*file
,
926 const char __user
*user_buf
,
927 size_t count
, loff_t
*ppos
)
929 struct wl1271
*wl
= file
->private_data
;
930 struct wl12xx_vif
*wlvif
;
934 ret
= kstrtoul_from_user(user_buf
, count
, 0, &value
);
936 wl1271_warning("illegal value for beacon_filtering!");
940 mutex_lock(&wl
->mutex
);
942 ret
= pm_runtime_get_sync(wl
->dev
);
944 pm_runtime_put_noidle(wl
->dev
);
948 wl12xx_for_each_wlvif(wl
, wlvif
) {
949 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, !!value
);
952 pm_runtime_mark_last_busy(wl
->dev
);
953 pm_runtime_put_autosuspend(wl
->dev
);
955 mutex_unlock(&wl
->mutex
);
959 static const struct file_operations beacon_filtering_ops
= {
960 .write
= beacon_filtering_write
,
962 .llseek
= default_llseek
,
965 static ssize_t
fw_stats_raw_read(struct file
*file
,
966 char __user
*userbuf
,
967 size_t count
, loff_t
*ppos
)
969 struct wl1271
*wl
= file
->private_data
;
971 wl1271_debugfs_update_stats(wl
);
973 return simple_read_from_buffer(userbuf
, count
, ppos
,
975 wl
->stats
.fw_stats_len
);
978 static const struct file_operations fw_stats_raw_ops
= {
979 .read
= fw_stats_raw_read
,
981 .llseek
= default_llseek
,
984 static ssize_t
sleep_auth_read(struct file
*file
, char __user
*user_buf
,
985 size_t count
, loff_t
*ppos
)
987 struct wl1271
*wl
= file
->private_data
;
989 return wl1271_format_buffer(user_buf
, count
,
994 static ssize_t
sleep_auth_write(struct file
*file
,
995 const char __user
*user_buf
,
996 size_t count
, loff_t
*ppos
)
998 struct wl1271
*wl
= file
->private_data
;
1002 ret
= kstrtoul_from_user(user_buf
, count
, 0, &value
);
1004 wl1271_warning("illegal value in sleep_auth");
1008 if (value
> WL1271_PSM_MAX
) {
1009 wl1271_warning("sleep_auth must be between 0 and %d",
1014 mutex_lock(&wl
->mutex
);
1016 wl
->conf
.conn
.sta_sleep_auth
= value
;
1018 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
1019 /* this will show up on "read" in case we are off */
1020 wl
->sleep_auth
= value
;
1024 ret
= pm_runtime_get_sync(wl
->dev
);
1026 pm_runtime_put_noidle(wl
->dev
);
1030 ret
= wl1271_acx_sleep_auth(wl
, value
);
1035 pm_runtime_mark_last_busy(wl
->dev
);
1036 pm_runtime_put_autosuspend(wl
->dev
);
1038 mutex_unlock(&wl
->mutex
);
1042 static const struct file_operations sleep_auth_ops
= {
1043 .read
= sleep_auth_read
,
1044 .write
= sleep_auth_write
,
1045 .open
= simple_open
,
1046 .llseek
= default_llseek
,
1049 static ssize_t
dev_mem_read(struct file
*file
,
1050 char __user
*user_buf
, size_t count
,
1053 struct wl1271
*wl
= file
->private_data
;
1054 struct wlcore_partition_set part
, old_part
;
1055 size_t bytes
= count
;
1059 /* only requests of dword-aligned size and offset are supported */
1066 /* function should return in reasonable time */
1067 bytes
= min(bytes
, WLCORE_MAX_BLOCK_SIZE
);
1072 memset(&part
, 0, sizeof(part
));
1073 part
.mem
.start
= *ppos
;
1074 part
.mem
.size
= bytes
;
1076 buf
= kmalloc(bytes
, GFP_KERNEL
);
1080 mutex_lock(&wl
->mutex
);
1082 if (unlikely(wl
->state
== WLCORE_STATE_OFF
)) {
1088 * Don't fail if elp_wakeup returns an error, so the device's memory
1089 * could be read even if the FW crashed
1091 pm_runtime_get_sync(wl
->dev
);
1093 /* store current partition and switch partition */
1094 memcpy(&old_part
, &wl
->curr_part
, sizeof(old_part
));
1095 ret
= wlcore_set_partition(wl
, &part
);
1099 ret
= wlcore_raw_read(wl
, 0, buf
, bytes
, false);
1104 /* recover partition */
1105 ret
= wlcore_set_partition(wl
, &old_part
);
1110 pm_runtime_mark_last_busy(wl
->dev
);
1111 pm_runtime_put_autosuspend(wl
->dev
);
1114 mutex_unlock(&wl
->mutex
);
1117 ret
= copy_to_user(user_buf
, buf
, bytes
);
1129 return ((ret
== 0) ? bytes
: ret
);
1132 static ssize_t
dev_mem_write(struct file
*file
, const char __user
*user_buf
,
1133 size_t count
, loff_t
*ppos
)
1135 struct wl1271
*wl
= file
->private_data
;
1136 struct wlcore_partition_set part
, old_part
;
1137 size_t bytes
= count
;
1141 /* only requests of dword-aligned size and offset are supported */
1148 /* function should return in reasonable time */
1149 bytes
= min(bytes
, WLCORE_MAX_BLOCK_SIZE
);
1154 memset(&part
, 0, sizeof(part
));
1155 part
.mem
.start
= *ppos
;
1156 part
.mem
.size
= bytes
;
1158 buf
= memdup_user(user_buf
, bytes
);
1160 return PTR_ERR(buf
);
1162 mutex_lock(&wl
->mutex
);
1164 if (unlikely(wl
->state
== WLCORE_STATE_OFF
)) {
1170 * Don't fail if elp_wakeup returns an error, so the device's memory
1171 * could be read even if the FW crashed
1173 pm_runtime_get_sync(wl
->dev
);
1175 /* store current partition and switch partition */
1176 memcpy(&old_part
, &wl
->curr_part
, sizeof(old_part
));
1177 ret
= wlcore_set_partition(wl
, &part
);
1181 ret
= wlcore_raw_write(wl
, 0, buf
, bytes
, false);
1186 /* recover partition */
1187 ret
= wlcore_set_partition(wl
, &old_part
);
1192 pm_runtime_mark_last_busy(wl
->dev
);
1193 pm_runtime_put_autosuspend(wl
->dev
);
1196 mutex_unlock(&wl
->mutex
);
1203 return ((ret
== 0) ? bytes
: ret
);
1206 static loff_t
dev_mem_seek(struct file
*file
, loff_t offset
, int orig
)
1208 /* only requests of dword-aligned size and offset are supported */
1212 return no_seek_end_llseek(file
, offset
, orig
);
1215 static const struct file_operations dev_mem_ops
= {
1216 .open
= simple_open
,
1217 .read
= dev_mem_read
,
1218 .write
= dev_mem_write
,
1219 .llseek
= dev_mem_seek
,
1222 static ssize_t
fw_logger_read(struct file
*file
, char __user
*user_buf
,
1223 size_t count
, loff_t
*ppos
)
1225 struct wl1271
*wl
= file
->private_data
;
1227 return wl1271_format_buffer(user_buf
, count
,
1229 wl
->conf
.fwlog
.output
);
1232 static ssize_t
fw_logger_write(struct file
*file
,
1233 const char __user
*user_buf
,
1234 size_t count
, loff_t
*ppos
)
1236 struct wl1271
*wl
= file
->private_data
;
1237 unsigned long value
;
1240 ret
= kstrtoul_from_user(user_buf
, count
, 0, &value
);
1242 wl1271_warning("illegal value in fw_logger");
1246 if ((value
> 2) || (value
== 0)) {
1247 wl1271_warning("fw_logger value must be 1-UART 2-SDIO");
1251 if (wl
->conf
.fwlog
.output
== 0) {
1252 wl1271_warning("invalid operation - fw logger disabled by default, please change mode via wlconf");
1256 mutex_lock(&wl
->mutex
);
1257 ret
= pm_runtime_get_sync(wl
->dev
);
1259 pm_runtime_put_noidle(wl
->dev
);
1264 wl
->conf
.fwlog
.output
= value
;
1266 ret
= wl12xx_cmd_config_fwlog(wl
);
1268 pm_runtime_mark_last_busy(wl
->dev
);
1269 pm_runtime_put_autosuspend(wl
->dev
);
1272 mutex_unlock(&wl
->mutex
);
1276 static const struct file_operations fw_logger_ops
= {
1277 .open
= simple_open
,
1278 .read
= fw_logger_read
,
1279 .write
= fw_logger_write
,
1280 .llseek
= default_llseek
,
1283 static void wl1271_debugfs_add_files(struct wl1271
*wl
,
1284 struct dentry
*rootdir
)
1286 struct dentry
*streaming
;
1288 DEBUGFS_ADD(tx_queue_len
, rootdir
);
1289 DEBUGFS_ADD(retry_count
, rootdir
);
1290 DEBUGFS_ADD(excessive_retries
, rootdir
);
1292 DEBUGFS_ADD(gpio_power
, rootdir
);
1293 DEBUGFS_ADD(start_recovery
, rootdir
);
1294 DEBUGFS_ADD(driver_state
, rootdir
);
1295 DEBUGFS_ADD(vifs_state
, rootdir
);
1296 DEBUGFS_ADD(dtim_interval
, rootdir
);
1297 DEBUGFS_ADD(suspend_dtim_interval
, rootdir
);
1298 DEBUGFS_ADD(beacon_interval
, rootdir
);
1299 DEBUGFS_ADD(beacon_filtering
, rootdir
);
1300 DEBUGFS_ADD(dynamic_ps_timeout
, rootdir
);
1301 DEBUGFS_ADD(forced_ps
, rootdir
);
1302 DEBUGFS_ADD(split_scan_timeout
, rootdir
);
1303 DEBUGFS_ADD(irq_pkt_threshold
, rootdir
);
1304 DEBUGFS_ADD(irq_blk_threshold
, rootdir
);
1305 DEBUGFS_ADD(irq_timeout
, rootdir
);
1306 DEBUGFS_ADD(fw_stats_raw
, rootdir
);
1307 DEBUGFS_ADD(sleep_auth
, rootdir
);
1308 DEBUGFS_ADD(fw_logger
, rootdir
);
1310 streaming
= debugfs_create_dir("rx_streaming", rootdir
);
1312 DEBUGFS_ADD_PREFIX(rx_streaming
, interval
, streaming
);
1313 DEBUGFS_ADD_PREFIX(rx_streaming
, always
, streaming
);
1315 DEBUGFS_ADD_PREFIX(dev
, mem
, rootdir
);
1318 void wl1271_debugfs_reset(struct wl1271
*wl
)
1320 if (!wl
->stats
.fw_stats
)
1323 memset(wl
->stats
.fw_stats
, 0, wl
->stats
.fw_stats_len
);
1324 wl
->stats
.retry_count
= 0;
1325 wl
->stats
.excessive_retries
= 0;
1328 int wl1271_debugfs_init(struct wl1271
*wl
)
1331 struct dentry
*rootdir
;
1333 rootdir
= debugfs_create_dir(KBUILD_MODNAME
,
1334 wl
->hw
->wiphy
->debugfsdir
);
1336 wl
->stats
.fw_stats
= kzalloc(wl
->stats
.fw_stats_len
, GFP_KERNEL
);
1337 if (!wl
->stats
.fw_stats
) {
1342 wl
->stats
.fw_stats_update
= jiffies
;
1344 wl1271_debugfs_add_files(wl
, rootdir
);
1346 ret
= wlcore_debugfs_init(wl
, rootdir
);
1353 wl1271_debugfs_exit(wl
);
1356 debugfs_remove_recursive(rootdir
);
1362 void wl1271_debugfs_exit(struct wl1271
*wl
)
1364 kfree(wl
->stats
.fw_stats
);
1365 wl
->stats
.fw_stats
= NULL
;