projects/linux·blob master · refs

1337 lines · 32.1 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * This file is part of wl1271
4 *
5 * Copyright (C) 2009 Nokia Corporation
6 *
7 * Contact: Luciano Coelho <[email protected]>
8 */
9
10#include "debugfs.h"
11
12#include <linux/skbuff.h>
13#include <linux/slab.h>
14#include <linux/module.h>
15#include <linux/pm_runtime.h>
16
17#include "wlcore.h"
18#include "debug.h"
19#include "acx.h"
20#include "ps.h"
21#include "io.h"
22#include "tx.h"
23#include "hw_ops.h"
24
25/* ms */
26#define WL1271_DEBUGFS_STATS_LIFETIME 1000
27
28#define WLCORE_MAX_BLOCK_SIZE ((size_t)(4*PAGE_SIZE))
29
30/* debugfs macros idea from mac80211 */
31int wl1271_format_buffer(char __user *userbuf, size_t count,
32 loff_t *ppos, char *fmt, ...)
33{
34 va_list args;
35 char buf[DEBUGFS_FORMAT_BUFFER_SIZE];
36 int res;
37
38 va_start(args, fmt);
39 res = vscnprintf(buf, sizeof(buf), fmt, args);
40 va_end(args);
41
42 return simple_read_from_buffer(userbuf, count, ppos, buf, res);
43}
44EXPORT_SYMBOL_GPL(wl1271_format_buffer);
45
46void wl1271_debugfs_update_stats(struct wl1271 *wl)
47{
48 int ret;
49
50 mutex_lock(&wl->mutex);
51
52 if (unlikely(wl->state != WLCORE_STATE_ON))
53 goto out;
54
55 ret = pm_runtime_resume_and_get(wl->dev);
56 if (ret < 0)
57 goto out;
58
59 if (!wl->plt &&
60 time_after(jiffies, wl->stats.fw_stats_update +
61 msecs_to_jiffies(WL1271_DEBUGFS_STATS_LIFETIME))) {
62 wl1271_acx_statistics(wl, wl->stats.fw_stats);
63 wl->stats.fw_stats_update = jiffies;
64 }
65
66 pm_runtime_put_autosuspend(wl->dev);
67
68out:
69 mutex_unlock(&wl->mutex);
70}
71EXPORT_SYMBOL_GPL(wl1271_debugfs_update_stats);
72
73DEBUGFS_READONLY_FILE(retry_count, "%u", wl->stats.retry_count);
74DEBUGFS_READONLY_FILE(excessive_retries, "%u",
75 wl->stats.excessive_retries);
76
77static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
78 size_t count, loff_t *ppos)
79{
80 struct wl1271 *wl = file->private_data;
81 u32 queue_len;
82 char buf[20];
83 int res;
84
85 queue_len = wl1271_tx_total_queue_count(wl);
86
87 res = scnprintf(buf, sizeof(buf), "%u\n", queue_len);
88 return simple_read_from_buffer(userbuf, count, ppos, buf, res);
89}
90
91static const struct file_operations tx_queue_len_ops = {
92 .read = tx_queue_len_read,
93 .open = simple_open,
94 .llseek = default_llseek,
95};
96
97static void chip_op_handler(struct wl1271 *wl, unsigned long value,
98 void *arg)
99{
100 int ret;
101 int (*chip_op) (struct wl1271 *wl);
102
103 if (!arg) {
104 wl1271_warning("debugfs chip_op_handler with no callback");
105 return;
106 }
107
108 ret = pm_runtime_resume_and_get(wl->dev);
109 if (ret < 0)
110 return;
111
112 chip_op = arg;
113 chip_op(wl);
114
115 pm_runtime_put_autosuspend(wl->dev);
116}
117
118#define WL12XX_CONF_DEBUGFS(param, conf_sub_struct, \
119 min_val, max_val, write_handler_locked, \
120 write_handler_arg) \
121 static ssize_t param##_read(struct file *file, \
122 char __user *user_buf, \
123 size_t count, loff_t *ppos) \
124 { \
125 struct wl1271 *wl = file->private_data; \
126 return wl1271_format_buffer(user_buf, count, \
127 ppos, "%d\n", \
128 wl->conf.conf_sub_struct.param); \
129 } \
130 \
131 static ssize_t param##_write(struct file *file, \
132 const char __user *user_buf, \
133 size_t count, loff_t *ppos) \
134 { \
135 struct wl1271 *wl = file->private_data; \
136 unsigned long value; \
137 int ret; \
138 \
139 ret = kstrtoul_from_user(user_buf, count, 10, &value); \
140 if (ret < 0) { \
141 wl1271_warning("illegal value for " #param); \
142 return -EINVAL; \
143 } \
144 \
145 if (value < min_val || value > max_val) { \
146 wl1271_warning(#param " is not in valid range"); \
147 return -ERANGE; \
148 } \
149 \
150 mutex_lock(&wl->mutex); \
151 wl->conf.conf_sub_struct.param = value; \
152 \
153 write_handler_locked(wl, value, write_handler_arg); \
154 \
155 mutex_unlock(&wl->mutex); \
156 return count; \
157 } \
158 \
159 static const struct file_operations param##_ops = { \
160 .read = param##_read, \
161 .write = param##_write, \
162 .open = simple_open, \
163 .llseek = default_llseek, \
164 };
165
166WL12XX_CONF_DEBUGFS(irq_pkt_threshold, rx, 0, 65535,
167 chip_op_handler, wl1271_acx_init_rx_interrupt)
168WL12XX_CONF_DEBUGFS(irq_blk_threshold, rx, 0, 65535,
169 chip_op_handler, wl1271_acx_init_rx_interrupt)
170WL12XX_CONF_DEBUGFS(irq_timeout, rx, 0, 100,
171 chip_op_handler, wl1271_acx_init_rx_interrupt)
172
173static ssize_t gpio_power_read(struct file *file, char __user *user_buf,
174 size_t count, loff_t *ppos)
175{
176 struct wl1271 *wl = file->private_data;
177 bool state = test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
178
179 int res;
180 char buf[10];
181
182 res = scnprintf(buf, sizeof(buf), "%d\n", state);
183
184 return simple_read_from_buffer(user_buf, count, ppos, buf, res);
185}
186
187static ssize_t gpio_power_write(struct file *file,
188 const char __user *user_buf,
189 size_t count, loff_t *ppos)
190{
191 struct wl1271 *wl = file->private_data;
192 unsigned long value;
193 int ret;
194
195 ret = kstrtoul_from_user(user_buf, count, 10, &value);
196 if (ret < 0) {
197 wl1271_warning("illegal value in gpio_power");
198 return -EINVAL;
199 }
200
201 mutex_lock(&wl->mutex);
202
203 if (value)
204 wl1271_power_on(wl);
205 else
206 wl1271_power_off(wl);
207
208 mutex_unlock(&wl->mutex);
209 return count;
210}
211
212static const struct file_operations gpio_power_ops = {
213 .read = gpio_power_read,
214 .write = gpio_power_write,
215 .open = simple_open,
216 .llseek = default_llseek,
217};
218
219static ssize_t start_recovery_write(struct file *file,
220 const char __user *user_buf,
221 size_t count, loff_t *ppos)
222{
223 struct wl1271 *wl = file->private_data;
224
225 mutex_lock(&wl->mutex);
226 wl12xx_queue_recovery_work(wl);
227 mutex_unlock(&wl->mutex);
228
229 return count;
230}
231
232static const struct file_operations start_recovery_ops = {
233 .write = start_recovery_write,
234 .open = simple_open,
235 .llseek = default_llseek,
236};
237
238static ssize_t dynamic_ps_timeout_read(struct file *file, char __user *user_buf,
239 size_t count, loff_t *ppos)
240{
241 struct wl1271 *wl = file->private_data;
242
243 return wl1271_format_buffer(user_buf, count,
244 ppos, "%d\n",
245 wl->conf.conn.dynamic_ps_timeout);
246}
247
248static ssize_t dynamic_ps_timeout_write(struct file *file,
249 const char __user *user_buf,
250 size_t count, loff_t *ppos)
251{
252 struct wl1271 *wl = file->private_data;
253 struct wl12xx_vif *wlvif;
254 unsigned long value;
255 int ret;
256
257 ret = kstrtoul_from_user(user_buf, count, 10, &value);
258 if (ret < 0) {
259 wl1271_warning("illegal value in dynamic_ps");
260 return -EINVAL;
261 }
262
263 if (value < 1 || value > 65535) {
264 wl1271_warning("dynamic_ps_timeout is not in valid range");
265 return -ERANGE;
266 }
267
268 mutex_lock(&wl->mutex);
269
270 wl->conf.conn.dynamic_ps_timeout = value;
271
272 if (unlikely(wl->state != WLCORE_STATE_ON))
273 goto out;
274
275 ret = pm_runtime_resume_and_get(wl->dev);
276 if (ret < 0)
277 goto out;
278
279 /* In case we're already in PSM, trigger it again to set new timeout
280 * immediately without waiting for re-association
281 */
282
283 wl12xx_for_each_wlvif_sta(wl, wlvif) {
284 if (test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags))
285 wl1271_ps_set_mode(wl, wlvif, STATION_AUTO_PS_MODE);
286 }
287
288 pm_runtime_put_autosuspend(wl->dev);
289
290out:
291 mutex_unlock(&wl->mutex);
292 return count;
293}
294
295static const struct file_operations dynamic_ps_timeout_ops = {
296 .read = dynamic_ps_timeout_read,
297 .write = dynamic_ps_timeout_write,
298 .open = simple_open,
299 .llseek = default_llseek,
300};
301
302static ssize_t forced_ps_read(struct file *file, char __user *user_buf,
303 size_t count, loff_t *ppos)
304{
305 struct wl1271 *wl = file->private_data;
306
307 return wl1271_format_buffer(user_buf, count,
308 ppos, "%d\n",
309 wl->conf.conn.forced_ps);
310}
311
312static ssize_t forced_ps_write(struct file *file,
313 const char __user *user_buf,
314 size_t count, loff_t *ppos)
315{
316 struct wl1271 *wl = file->private_data;
317 struct wl12xx_vif *wlvif;
318 unsigned long value;
319 int ret, ps_mode;
320
321 ret = kstrtoul_from_user(user_buf, count, 10, &value);
322 if (ret < 0) {
323 wl1271_warning("illegal value in forced_ps");
324 return -EINVAL;
325 }
326
327 if (value != 1 && value != 0) {
328 wl1271_warning("forced_ps should be either 0 or 1");
329 return -ERANGE;
330 }
331
332 mutex_lock(&wl->mutex);
333
334 if (wl->conf.conn.forced_ps == value)
335 goto out;
336
337 wl->conf.conn.forced_ps = value;
338
339 if (unlikely(wl->state != WLCORE_STATE_ON))
340 goto out;
341
342 ret = pm_runtime_resume_and_get(wl->dev);
343 if (ret < 0)
344 goto out;
345
346 /* In case we're already in PSM, trigger it again to switch mode
347 * immediately without waiting for re-association
348 */
349
350 ps_mode = value ? STATION_POWER_SAVE_MODE : STATION_AUTO_PS_MODE;
351
352 wl12xx_for_each_wlvif_sta(wl, wlvif) {
353 if (test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags))
354 wl1271_ps_set_mode(wl, wlvif, ps_mode);
355 }
356
357 pm_runtime_put_autosuspend(wl->dev);
358
359out:
360 mutex_unlock(&wl->mutex);
361 return count;
362}
363
364static const struct file_operations forced_ps_ops = {
365 .read = forced_ps_read,
366 .write = forced_ps_write,
367 .open = simple_open,
368 .llseek = default_llseek,
369};
370
371static ssize_t split_scan_timeout_read(struct file *file, char __user *user_buf,
372 size_t count, loff_t *ppos)
373{
374 struct wl1271 *wl = file->private_data;
375
376 return wl1271_format_buffer(user_buf, count,
377 ppos, "%d\n",
378 wl->conf.scan.split_scan_timeout / 1000);
379}
380
381static ssize_t split_scan_timeout_write(struct file *file,
382 const char __user *user_buf,
383 size_t count, loff_t *ppos)
384{
385 struct wl1271 *wl = file->private_data;
386 unsigned long value;
387 int ret;
388
389 ret = kstrtoul_from_user(user_buf, count, 10, &value);
390 if (ret < 0) {
391 wl1271_warning("illegal value in split_scan_timeout");
392 return -EINVAL;
393 }
394
395 if (value == 0)
396 wl1271_info("split scan will be disabled");
397
398 mutex_lock(&wl->mutex);
399
400 wl->conf.scan.split_scan_timeout = value * 1000;
401
402 mutex_unlock(&wl->mutex);
403 return count;
404}
405
406static const struct file_operations split_scan_timeout_ops = {
407 .read = split_scan_timeout_read,
408 .write = split_scan_timeout_write,
409 .open = simple_open,
410 .llseek = default_llseek,
411};
412
413static ssize_t driver_state_read(struct file *file, char __user *user_buf,
414 size_t count, loff_t *ppos)
415{
416 struct wl1271 *wl = file->private_data;
417 int res = 0;
418 ssize_t ret;
419 char *buf;
420 struct wl12xx_vif *wlvif;
421
422#define DRIVER_STATE_BUF_LEN 1024
423
424 buf = kmalloc(DRIVER_STATE_BUF_LEN, GFP_KERNEL);
425 if (!buf)
426 return -ENOMEM;
427
428 mutex_lock(&wl->mutex);
429
430#define DRIVER_STATE_PRINT(x, fmt) \
431 (res += scnprintf(buf + res, DRIVER_STATE_BUF_LEN - res,\
432 #x " = " fmt "\n", wl->x))
433
434#define DRIVER_STATE_PRINT_GENERIC(x, fmt, args...) \
435 (res += scnprintf(buf + res, DRIVER_STATE_BUF_LEN - res,\
436 #x " = " fmt "\n", args))
437
438#define DRIVER_STATE_PRINT_LONG(x) DRIVER_STATE_PRINT(x, "%ld")
439#define DRIVER_STATE_PRINT_INT(x) DRIVER_STATE_PRINT(x, "%d")
440#define DRIVER_STATE_PRINT_STR(x) DRIVER_STATE_PRINT(x, "%s")
441#define DRIVER_STATE_PRINT_LHEX(x) DRIVER_STATE_PRINT(x, "0x%lx")
442#define DRIVER_STATE_PRINT_HEX(x) DRIVER_STATE_PRINT(x, "0x%x")
443
444 wl12xx_for_each_wlvif_sta(wl, wlvif) {
445 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
446 continue;
447
448 DRIVER_STATE_PRINT_GENERIC(channel, "%d (%s)", wlvif->channel,
449 wlvif->p2p ? "P2P-CL" : "STA");
450 }
451
452 wl12xx_for_each_wlvif_ap(wl, wlvif)
453 DRIVER_STATE_PRINT_GENERIC(channel, "%d (%s)", wlvif->channel,
454 wlvif->p2p ? "P2P-GO" : "AP");
455
456 DRIVER_STATE_PRINT_INT(tx_blocks_available);
457 DRIVER_STATE_PRINT_INT(tx_allocated_blocks);
458 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[0]);
459 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[1]);
460 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[2]);
461 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[3]);
462 DRIVER_STATE_PRINT_INT(tx_frames_cnt);
463 DRIVER_STATE_PRINT_LHEX(tx_frames_map[0]);
464 DRIVER_STATE_PRINT_INT(tx_queue_count[0]);
465 DRIVER_STATE_PRINT_INT(tx_queue_count[1]);
466 DRIVER_STATE_PRINT_INT(tx_queue_count[2]);
467 DRIVER_STATE_PRINT_INT(tx_queue_count[3]);
468 DRIVER_STATE_PRINT_INT(tx_packets_count);
469 DRIVER_STATE_PRINT_INT(tx_results_count);
470 DRIVER_STATE_PRINT_LHEX(flags);
471 DRIVER_STATE_PRINT_INT(tx_blocks_freed);
472 DRIVER_STATE_PRINT_INT(rx_counter);
473 DRIVER_STATE_PRINT_INT(state);
474 DRIVER_STATE_PRINT_INT(band);
475 DRIVER_STATE_PRINT_INT(power_level);
476 DRIVER_STATE_PRINT_INT(sg_enabled);
477 DRIVER_STATE_PRINT_INT(enable_11a);
478 DRIVER_STATE_PRINT_INT(noise);
479 DRIVER_STATE_PRINT_LHEX(ap_fw_ps_map);
480 DRIVER_STATE_PRINT_LHEX(ap_ps_map);
481 DRIVER_STATE_PRINT_HEX(quirks);
482 DRIVER_STATE_PRINT_HEX(irq);
483 /* TODO: ref_clock and tcxo_clock were moved to wl12xx priv */
484 DRIVER_STATE_PRINT_HEX(hw_pg_ver);
485 DRIVER_STATE_PRINT_HEX(irq_flags);
486 DRIVER_STATE_PRINT_HEX(chip.id);
487 DRIVER_STATE_PRINT_STR(chip.fw_ver_str);
488 DRIVER_STATE_PRINT_STR(chip.phy_fw_ver_str);
489 DRIVER_STATE_PRINT_INT(recovery_count);
490
491#undef DRIVER_STATE_PRINT_INT
492#undef DRIVER_STATE_PRINT_LONG
493#undef DRIVER_STATE_PRINT_HEX
494#undef DRIVER_STATE_PRINT_LHEX
495#undef DRIVER_STATE_PRINT_STR
496#undef DRIVER_STATE_PRINT
497#undef DRIVER_STATE_BUF_LEN
498
499 mutex_unlock(&wl->mutex);
500
501 ret = simple_read_from_buffer(user_buf, count, ppos, buf, res);
502 kfree(buf);
503 return ret;
504}
505
506static const struct file_operations driver_state_ops = {
507 .read = driver_state_read,
508 .open = simple_open,
509 .llseek = default_llseek,
510};
511
512static ssize_t vifs_state_read(struct file *file, char __user *user_buf,
513 size_t count, loff_t *ppos)
514{
515 struct wl1271 *wl = file->private_data;
516 struct wl12xx_vif *wlvif;
517 int ret, res = 0;
518 const int buf_size = 4096;
519 char *buf;
520 char tmp_buf[64];
521
522 buf = kzalloc(buf_size, GFP_KERNEL);
523 if (!buf)
524 return -ENOMEM;
525
526 mutex_lock(&wl->mutex);
527
528#define VIF_STATE_PRINT(x, fmt) \
529 (res += scnprintf(buf + res, buf_size - res, \
530 #x " = " fmt "\n", wlvif->x))
531
532#define VIF_STATE_PRINT_LONG(x) VIF_STATE_PRINT(x, "%ld")
533#define VIF_STATE_PRINT_INT(x) VIF_STATE_PRINT(x, "%d")
534#define VIF_STATE_PRINT_STR(x) VIF_STATE_PRINT(x, "%s")
535#define VIF_STATE_PRINT_LHEX(x) VIF_STATE_PRINT(x, "0x%lx")
536#define VIF_STATE_PRINT_LLHEX(x) VIF_STATE_PRINT(x, "0x%llx")
537#define VIF_STATE_PRINT_HEX(x) VIF_STATE_PRINT(x, "0x%x")
538
539#define VIF_STATE_PRINT_NSTR(x, len) \
540 do { \
541 memset(tmp_buf, 0, sizeof(tmp_buf)); \
542 memcpy(tmp_buf, wlvif->x, \
543 min_t(u8, len, sizeof(tmp_buf) - 1)); \
544 res += scnprintf(buf + res, buf_size - res, \
545 #x " = %s\n", tmp_buf); \
546 } while (0)
547
548 wl12xx_for_each_wlvif(wl, wlvif) {
549 VIF_STATE_PRINT_INT(role_id);
550 VIF_STATE_PRINT_INT(bss_type);
551 VIF_STATE_PRINT_LHEX(flags);
552 VIF_STATE_PRINT_INT(p2p);
553 VIF_STATE_PRINT_INT(dev_role_id);
554 VIF_STATE_PRINT_INT(dev_hlid);
555
556 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
557 wlvif->bss_type == BSS_TYPE_IBSS) {
558 VIF_STATE_PRINT_INT(sta.hlid);
559 VIF_STATE_PRINT_INT(sta.basic_rate_idx);
560 VIF_STATE_PRINT_INT(sta.ap_rate_idx);
561 VIF_STATE_PRINT_INT(sta.p2p_rate_idx);
562 VIF_STATE_PRINT_INT(sta.qos);
563 } else {
564 VIF_STATE_PRINT_INT(ap.global_hlid);
565 VIF_STATE_PRINT_INT(ap.bcast_hlid);
566 VIF_STATE_PRINT_LHEX(ap.sta_hlid_map[0]);
567 VIF_STATE_PRINT_INT(ap.mgmt_rate_idx);
568 VIF_STATE_PRINT_INT(ap.bcast_rate_idx);
569 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[0]);
570 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[1]);
571 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[2]);
572 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[3]);
573 }
574 VIF_STATE_PRINT_INT(last_tx_hlid);
575 VIF_STATE_PRINT_INT(tx_queue_count[0]);
576 VIF_STATE_PRINT_INT(tx_queue_count[1]);
577 VIF_STATE_PRINT_INT(tx_queue_count[2]);
578 VIF_STATE_PRINT_INT(tx_queue_count[3]);
579 VIF_STATE_PRINT_LHEX(links_map[0]);
580 VIF_STATE_PRINT_NSTR(ssid, wlvif->ssid_len);
581 VIF_STATE_PRINT_INT(band);
582 VIF_STATE_PRINT_INT(channel);
583 VIF_STATE_PRINT_HEX(bitrate_masks[0]);
584 VIF_STATE_PRINT_HEX(bitrate_masks[1]);
585 VIF_STATE_PRINT_HEX(basic_rate_set);
586 VIF_STATE_PRINT_HEX(basic_rate);
587 VIF_STATE_PRINT_HEX(rate_set);
588 VIF_STATE_PRINT_INT(beacon_int);
589 VIF_STATE_PRINT_INT(default_key);
590 VIF_STATE_PRINT_INT(aid);
591 VIF_STATE_PRINT_INT(psm_entry_retry);
592 VIF_STATE_PRINT_INT(power_level);
593 VIF_STATE_PRINT_INT(rssi_thold);
594 VIF_STATE_PRINT_INT(last_rssi_event);
595 VIF_STATE_PRINT_INT(ba_support);
596 VIF_STATE_PRINT_INT(ba_allowed);
597 VIF_STATE_PRINT_LLHEX(total_freed_pkts);
598 }
599
600#undef VIF_STATE_PRINT_INT
601#undef VIF_STATE_PRINT_LONG
602#undef VIF_STATE_PRINT_HEX
603#undef VIF_STATE_PRINT_LHEX
604#undef VIF_STATE_PRINT_LLHEX
605#undef VIF_STATE_PRINT_STR
606#undef VIF_STATE_PRINT_NSTR
607#undef VIF_STATE_PRINT
608
609 mutex_unlock(&wl->mutex);
610
611 ret = simple_read_from_buffer(user_buf, count, ppos, buf, res);
612 kfree(buf);
613 return ret;
614}
615
616static const struct file_operations vifs_state_ops = {
617 .read = vifs_state_read,
618 .open = simple_open,
619 .llseek = default_llseek,
620};
621
622static ssize_t dtim_interval_read(struct file *file, char __user *user_buf,
623 size_t count, loff_t *ppos)
624{
625 struct wl1271 *wl = file->private_data;
626 u8 value;
627
628 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_DTIM ||
629 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM)
630 value = wl->conf.conn.listen_interval;
631 else
632 value = 0;
633
634 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
635}
636
637static ssize_t dtim_interval_write(struct file *file,
638 const char __user *user_buf,
639 size_t count, loff_t *ppos)
640{
641 struct wl1271 *wl = file->private_data;
642 unsigned long value;
643 int ret;
644
645 ret = kstrtoul_from_user(user_buf, count, 10, &value);
646 if (ret < 0) {
647 wl1271_warning("illegal value for dtim_interval");
648 return -EINVAL;
649 }
650
651 if (value < 1 || value > 10) {
652 wl1271_warning("dtim value is not in valid range");
653 return -ERANGE;
654 }
655
656 mutex_lock(&wl->mutex);
657
658 wl->conf.conn.listen_interval = value;
659 /* for some reason there are different event types for 1 and >1 */
660 if (value == 1)
661 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_DTIM;
662 else
663 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM;
664
665 /*
666 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
667 * take effect on the next time we enter psm.
668 */
669 mutex_unlock(&wl->mutex);
670 return count;
671}
672
673static const struct file_operations dtim_interval_ops = {
674 .read = dtim_interval_read,
675 .write = dtim_interval_write,
676 .open = simple_open,
677 .llseek = default_llseek,
678};
679
680
681
682static ssize_t suspend_dtim_interval_read(struct file *file,
683 char __user *user_buf,
684 size_t count, loff_t *ppos)
685{
686 struct wl1271 *wl = file->private_data;
687 u8 value;
688
689 if (wl->conf.conn.suspend_wake_up_event == CONF_WAKE_UP_EVENT_DTIM ||
690 wl->conf.conn.suspend_wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM)
691 value = wl->conf.conn.suspend_listen_interval;
692 else
693 value = 0;
694
695 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
696}
697
698static ssize_t suspend_dtim_interval_write(struct file *file,
699 const char __user *user_buf,
700 size_t count, loff_t *ppos)
701{
702 struct wl1271 *wl = file->private_data;
703 unsigned long value;
704 int ret;
705
706 ret = kstrtoul_from_user(user_buf, count, 10, &value);
707 if (ret < 0) {
708 wl1271_warning("illegal value for suspend_dtim_interval");
709 return -EINVAL;
710 }
711
712 if (value < 1 || value > 10) {
713 wl1271_warning("suspend_dtim value is not in valid range");
714 return -ERANGE;
715 }
716
717 mutex_lock(&wl->mutex);
718
719 wl->conf.conn.suspend_listen_interval = value;
720 /* for some reason there are different event types for 1 and >1 */
721 if (value == 1)
722 wl->conf.conn.suspend_wake_up_event = CONF_WAKE_UP_EVENT_DTIM;
723 else
724 wl->conf.conn.suspend_wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM;
725
726 mutex_unlock(&wl->mutex);
727 return count;
728}
729
730
731static const struct file_operations suspend_dtim_interval_ops = {
732 .read = suspend_dtim_interval_read,
733 .write = suspend_dtim_interval_write,
734 .open = simple_open,
735 .llseek = default_llseek,
736};
737
738static ssize_t beacon_interval_read(struct file *file, char __user *user_buf,
739 size_t count, loff_t *ppos)
740{
741 struct wl1271 *wl = file->private_data;
742 u8 value;
743
744 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_BEACON ||
745 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_BEACONS)
746 value = wl->conf.conn.listen_interval;
747 else
748 value = 0;
749
750 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value);
751}
752
753static ssize_t beacon_interval_write(struct file *file,
754 const char __user *user_buf,
755 size_t count, loff_t *ppos)
756{
757 struct wl1271 *wl = file->private_data;
758 unsigned long value;
759 int ret;
760
761 ret = kstrtoul_from_user(user_buf, count, 10, &value);
762 if (ret < 0) {
763 wl1271_warning("illegal value for beacon_interval");
764 return -EINVAL;
765 }
766
767 if (value < 1 || value > 255) {
768 wl1271_warning("beacon interval value is not in valid range");
769 return -ERANGE;
770 }
771
772 mutex_lock(&wl->mutex);
773
774 wl->conf.conn.listen_interval = value;
775 /* for some reason there are different event types for 1 and >1 */
776 if (value == 1)
777 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_BEACON;
778 else
779 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_BEACONS;
780
781 /*
782 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only
783 * take effect on the next time we enter psm.
784 */
785 mutex_unlock(&wl->mutex);
786 return count;
787}
788
789static const struct file_operations beacon_interval_ops = {
790 .read = beacon_interval_read,
791 .write = beacon_interval_write,
792 .open = simple_open,
793 .llseek = default_llseek,
794};
795
796static ssize_t rx_streaming_interval_write(struct file *file,
797 const char __user *user_buf,
798 size_t count, loff_t *ppos)
799{
800 struct wl1271 *wl = file->private_data;
801 struct wl12xx_vif *wlvif;
802 unsigned long value;
803 int ret;
804
805 ret = kstrtoul_from_user(user_buf, count, 10, &value);
806 if (ret < 0) {
807 wl1271_warning("illegal value in rx_streaming_interval!");
808 return -EINVAL;
809 }
810
811 /* valid values: 0, 10-100 */
812 if (value && (value < 10 || value > 100)) {
813 wl1271_warning("value is not in range!");
814 return -ERANGE;
815 }
816
817 mutex_lock(&wl->mutex);
818
819 wl->conf.rx_streaming.interval = value;
820
821 ret = pm_runtime_resume_and_get(wl->dev);
822 if (ret < 0)
823 goto out;
824
825 wl12xx_for_each_wlvif_sta(wl, wlvif) {
826 wl1271_recalc_rx_streaming(wl, wlvif);
827 }
828
829 pm_runtime_put_autosuspend(wl->dev);
830out:
831 mutex_unlock(&wl->mutex);
832 return count;
833}
834
835static ssize_t rx_streaming_interval_read(struct file *file,
836 char __user *userbuf,
837 size_t count, loff_t *ppos)
838{
839 struct wl1271 *wl = file->private_data;
840 return wl1271_format_buffer(userbuf, count, ppos,
841 "%d\n", wl->conf.rx_streaming.interval);
842}
843
844static const struct file_operations rx_streaming_interval_ops = {
845 .read = rx_streaming_interval_read,
846 .write = rx_streaming_interval_write,
847 .open = simple_open,
848 .llseek = default_llseek,
849};
850
851static ssize_t rx_streaming_always_write(struct file *file,
852 const char __user *user_buf,
853 size_t count, loff_t *ppos)
854{
855 struct wl1271 *wl = file->private_data;
856 struct wl12xx_vif *wlvif;
857 unsigned long value;
858 int ret;
859
860 ret = kstrtoul_from_user(user_buf, count, 10, &value);
861 if (ret < 0) {
862 wl1271_warning("illegal value in rx_streaming_write!");
863 return -EINVAL;
864 }
865
866 /* valid values: 0, 10-100 */
867 if (!(value == 0 || value == 1)) {
868 wl1271_warning("value is not in valid!");
869 return -EINVAL;
870 }
871
872 mutex_lock(&wl->mutex);
873
874 wl->conf.rx_streaming.always = value;
875
876 ret = pm_runtime_resume_and_get(wl->dev);
877 if (ret < 0)
878 goto out;
879
880 wl12xx_for_each_wlvif_sta(wl, wlvif) {
881 wl1271_recalc_rx_streaming(wl, wlvif);
882 }
883
884 pm_runtime_put_autosuspend(wl->dev);
885out:
886 mutex_unlock(&wl->mutex);
887 return count;
888}
889
890static ssize_t rx_streaming_always_read(struct file *file,
891 char __user *userbuf,
892 size_t count, loff_t *ppos)
893{
894 struct wl1271 *wl = file->private_data;
895 return wl1271_format_buffer(userbuf, count, ppos,
896 "%d\n", wl->conf.rx_streaming.always);
897}
898
899static const struct file_operations rx_streaming_always_ops = {
900 .read = rx_streaming_always_read,
901 .write = rx_streaming_always_write,
902 .open = simple_open,
903 .llseek = default_llseek,
904};
905
906static ssize_t beacon_filtering_write(struct file *file,
907 const char __user *user_buf,
908 size_t count, loff_t *ppos)
909{
910 struct wl1271 *wl = file->private_data;
911 struct wl12xx_vif *wlvif;
912 unsigned long value;
913 int ret;
914
915 ret = kstrtoul_from_user(user_buf, count, 0, &value);
916 if (ret < 0) {
917 wl1271_warning("illegal value for beacon_filtering!");
918 return -EINVAL;
919 }
920
921 mutex_lock(&wl->mutex);
922
923 ret = pm_runtime_resume_and_get(wl->dev);
924 if (ret < 0)
925 goto out;
926
927 wl12xx_for_each_wlvif(wl, wlvif) {
928 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, !!value);
929 }
930
931 pm_runtime_put_autosuspend(wl->dev);
932out:
933 mutex_unlock(&wl->mutex);
934 return count;
935}
936
937static const struct file_operations beacon_filtering_ops = {
938 .write = beacon_filtering_write,
939 .open = simple_open,
940 .llseek = default_llseek,
941};
942
943static ssize_t fw_stats_raw_read(struct file *file,
944 char __user *userbuf,
945 size_t count, loff_t *ppos)
946{
947 struct wl1271 *wl = file->private_data;
948
949 wl1271_debugfs_update_stats(wl);
950
951 return simple_read_from_buffer(userbuf, count, ppos,
952 wl->stats.fw_stats,
953 wl->stats.fw_stats_len);
954}
955
956static const struct file_operations fw_stats_raw_ops = {
957 .read = fw_stats_raw_read,
958 .open = simple_open,
959 .llseek = default_llseek,
960};
961
962static ssize_t sleep_auth_read(struct file *file, char __user *user_buf,
963 size_t count, loff_t *ppos)
964{
965 struct wl1271 *wl = file->private_data;
966
967 return wl1271_format_buffer(user_buf, count,
968 ppos, "%d\n",
969 wl->sleep_auth);
970}
971
972static ssize_t sleep_auth_write(struct file *file,
973 const char __user *user_buf,
974 size_t count, loff_t *ppos)
975{
976 struct wl1271 *wl = file->private_data;
977 unsigned long value;
978 int ret;
979
980 ret = kstrtoul_from_user(user_buf, count, 0, &value);
981 if (ret < 0) {
982 wl1271_warning("illegal value in sleep_auth");
983 return -EINVAL;
984 }
985
986 if (value > WL1271_PSM_MAX) {
987 wl1271_warning("sleep_auth must be between 0 and %d",
988 WL1271_PSM_MAX);
989 return -ERANGE;
990 }
991
992 mutex_lock(&wl->mutex);
993
994 wl->conf.conn.sta_sleep_auth = value;
995
996 if (unlikely(wl->state != WLCORE_STATE_ON)) {
997 /* this will show up on "read" in case we are off */
998 wl->sleep_auth = value;
999 goto out;
1000 }
1001
1002 ret = pm_runtime_resume_and_get(wl->dev);
1003 if (ret < 0)
1004 goto out;
1005
1006 ret = wl1271_acx_sleep_auth(wl, value);
1007 if (ret < 0)
1008 goto out_sleep;
1009
1010out_sleep:
1011 pm_runtime_put_autosuspend(wl->dev);
1012out:
1013 mutex_unlock(&wl->mutex);
1014 return count;
1015}
1016
1017static const struct file_operations sleep_auth_ops = {
1018 .read = sleep_auth_read,
1019 .write = sleep_auth_write,
1020 .open = simple_open,
1021 .llseek = default_llseek,
1022};
1023
1024static ssize_t dev_mem_read(struct file *file,
1025 char __user *user_buf, size_t count,
1026 loff_t *ppos)
1027{
1028 struct wl1271 *wl = file->private_data;
1029 struct wlcore_partition_set part, old_part;
1030 size_t bytes = count;
1031 int ret;
1032 char *buf;
1033
1034 /* only requests of dword-aligned size and offset are supported */
1035 if (bytes % 4)
1036 return -EINVAL;
1037
1038 if (*ppos % 4)
1039 return -EINVAL;
1040
1041 /* function should return in reasonable time */
1042 bytes = min(bytes, WLCORE_MAX_BLOCK_SIZE);
1043
1044 if (bytes == 0)
1045 return -EINVAL;
1046
1047 memset(&part, 0, sizeof(part));
1048 part.mem.start = *ppos;
1049 part.mem.size = bytes;
1050
1051 buf = kmalloc(bytes, GFP_KERNEL);
1052 if (!buf)
1053 return -ENOMEM;
1054
1055 mutex_lock(&wl->mutex);
1056
1057 if (unlikely(wl->state == WLCORE_STATE_OFF)) {
1058 ret = -EFAULT;
1059 goto skip_read;
1060 }
1061
1062 /*
1063 * Don't fail if elp_wakeup returns an error, so the device's memory
1064 * could be read even if the FW crashed
1065 */
1066 pm_runtime_get_sync(wl->dev);
1067
1068 /* store current partition and switch partition */
1069 memcpy(&old_part, &wl->curr_part, sizeof(old_part));
1070 ret = wlcore_set_partition(wl, &part);
1071 if (ret < 0)
1072 goto part_err;
1073
1074 ret = wlcore_raw_read(wl, 0, buf, bytes, false);
1075 if (ret < 0)
1076 goto read_err;
1077
1078read_err:
1079 /* recover partition */
1080 ret = wlcore_set_partition(wl, &old_part);
1081 if (ret < 0)
1082 goto part_err;
1083
1084part_err:
1085 pm_runtime_put_autosuspend(wl->dev);
1086
1087skip_read:
1088 mutex_unlock(&wl->mutex);
1089
1090 if (ret == 0) {
1091 ret = copy_to_user(user_buf, buf, bytes);
1092 if (ret < bytes) {
1093 bytes -= ret;
1094 *ppos += bytes;
1095 ret = 0;
1096 } else {
1097 ret = -EFAULT;
1098 }
1099 }
1100
1101 kfree(buf);
1102
1103 return ((ret == 0) ? bytes : ret);
1104}
1105
1106static ssize_t dev_mem_write(struct file *file, const char __user *user_buf,
1107 size_t count, loff_t *ppos)
1108{
1109 struct wl1271 *wl = file->private_data;
1110 struct wlcore_partition_set part, old_part;
1111 size_t bytes = count;
1112 int ret;
1113 char *buf;
1114
1115 /* only requests of dword-aligned size and offset are supported */
1116 if (bytes % 4)
1117 return -EINVAL;
1118
1119 if (*ppos % 4)
1120 return -EINVAL;
1121
1122 /* function should return in reasonable time */
1123 bytes = min(bytes, WLCORE_MAX_BLOCK_SIZE);
1124
1125 if (bytes == 0)
1126 return -EINVAL;
1127
1128 memset(&part, 0, sizeof(part));
1129 part.mem.start = *ppos;
1130 part.mem.size = bytes;
1131
1132 buf = memdup_user(user_buf, bytes);
1133 if (IS_ERR(buf))
1134 return PTR_ERR(buf);
1135
1136 mutex_lock(&wl->mutex);
1137
1138 if (unlikely(wl->state == WLCORE_STATE_OFF)) {
1139 ret = -EFAULT;
1140 goto skip_write;
1141 }
1142
1143 /*
1144 * Don't fail if elp_wakeup returns an error, so the device's memory
1145 * could be read even if the FW crashed
1146 */
1147 pm_runtime_get_sync(wl->dev);
1148
1149 /* store current partition and switch partition */
1150 memcpy(&old_part, &wl->curr_part, sizeof(old_part));
1151 ret = wlcore_set_partition(wl, &part);
1152 if (ret < 0)
1153 goto part_err;
1154
1155 ret = wlcore_raw_write(wl, 0, buf, bytes, false);
1156 if (ret < 0)
1157 goto write_err;
1158
1159write_err:
1160 /* recover partition */
1161 ret = wlcore_set_partition(wl, &old_part);
1162 if (ret < 0)
1163 goto part_err;
1164
1165part_err:
1166 pm_runtime_put_autosuspend(wl->dev);
1167
1168skip_write:
1169 mutex_unlock(&wl->mutex);
1170
1171 if (ret == 0)
1172 *ppos += bytes;
1173
1174 kfree(buf);
1175
1176 return ((ret == 0) ? bytes : ret);
1177}
1178
1179static loff_t dev_mem_seek(struct file *file, loff_t offset, int orig)
1180{
1181 /* only requests of dword-aligned size and offset are supported */
1182 if (offset % 4)
1183 return -EINVAL;
1184
1185 return no_seek_end_llseek(file, offset, orig);
1186}
1187
1188static const struct file_operations dev_mem_ops = {
1189 .open = simple_open,
1190 .read = dev_mem_read,
1191 .write = dev_mem_write,
1192 .llseek = dev_mem_seek,
1193};
1194
1195static ssize_t fw_logger_read(struct file *file, char __user *user_buf,
1196 size_t count, loff_t *ppos)
1197{
1198 struct wl1271 *wl = file->private_data;
1199
1200 return wl1271_format_buffer(user_buf, count,
1201 ppos, "%d\n",
1202 wl->conf.fwlog.output);
1203}
1204
1205static ssize_t fw_logger_write(struct file *file,
1206 const char __user *user_buf,
1207 size_t count, loff_t *ppos)
1208{
1209 struct wl1271 *wl = file->private_data;
1210 unsigned long value;
1211 int ret;
1212
1213 ret = kstrtoul_from_user(user_buf, count, 0, &value);
1214 if (ret < 0) {
1215 wl1271_warning("illegal value in fw_logger");
1216 return -EINVAL;
1217 }
1218
1219 if ((value > 2) || (value == 0)) {
1220 wl1271_warning("fw_logger value must be 1-UART 2-SDIO");
1221 return -ERANGE;
1222 }
1223
1224 if (wl->conf.fwlog.output == 0) {
1225 wl1271_warning("invalid operation - fw logger disabled by default, please change mode via wlconf");
1226 return -EINVAL;
1227 }
1228
1229 mutex_lock(&wl->mutex);
1230 ret = pm_runtime_resume_and_get(wl->dev);
1231 if (ret < 0) {
1232 count = ret;
1233 goto out;
1234 }
1235
1236 wl->conf.fwlog.output = value;
1237
1238 ret = wl12xx_cmd_config_fwlog(wl);
1239
1240 pm_runtime_put_autosuspend(wl->dev);
1241
1242out:
1243 mutex_unlock(&wl->mutex);
1244 return count;
1245}
1246
1247static const struct file_operations fw_logger_ops = {
1248 .open = simple_open,
1249 .read = fw_logger_read,
1250 .write = fw_logger_write,
1251 .llseek = default_llseek,
1252};
1253
1254static void wl1271_debugfs_add_files(struct wl1271 *wl,
1255 struct dentry *rootdir)
1256{
1257 struct dentry *streaming;
1258
1259 DEBUGFS_ADD(tx_queue_len, rootdir);
1260 DEBUGFS_ADD(retry_count, rootdir);
1261 DEBUGFS_ADD(excessive_retries, rootdir);
1262
1263 DEBUGFS_ADD(gpio_power, rootdir);
1264 DEBUGFS_ADD(start_recovery, rootdir);
1265 DEBUGFS_ADD(driver_state, rootdir);
1266 DEBUGFS_ADD(vifs_state, rootdir);
1267 DEBUGFS_ADD(dtim_interval, rootdir);
1268 DEBUGFS_ADD(suspend_dtim_interval, rootdir);
1269 DEBUGFS_ADD(beacon_interval, rootdir);
1270 DEBUGFS_ADD(beacon_filtering, rootdir);
1271 DEBUGFS_ADD(dynamic_ps_timeout, rootdir);
1272 DEBUGFS_ADD(forced_ps, rootdir);
1273 DEBUGFS_ADD(split_scan_timeout, rootdir);
1274 DEBUGFS_ADD(irq_pkt_threshold, rootdir);
1275 DEBUGFS_ADD(irq_blk_threshold, rootdir);
1276 DEBUGFS_ADD(irq_timeout, rootdir);
1277 DEBUGFS_ADD(fw_stats_raw, rootdir);
1278 DEBUGFS_ADD(sleep_auth, rootdir);
1279 DEBUGFS_ADD(fw_logger, rootdir);
1280
1281 streaming = debugfs_create_dir("rx_streaming", rootdir);
1282
1283 DEBUGFS_ADD_PREFIX(rx_streaming, interval, streaming);
1284 DEBUGFS_ADD_PREFIX(rx_streaming, always, streaming);
1285
1286 DEBUGFS_ADD_PREFIX(dev, mem, rootdir);
1287}
1288
1289void wl1271_debugfs_reset(struct wl1271 *wl)
1290{
1291 if (!wl->stats.fw_stats)
1292 return;
1293
1294 memset(wl->stats.fw_stats, 0, wl->stats.fw_stats_len);
1295 wl->stats.retry_count = 0;
1296 wl->stats.excessive_retries = 0;
1297}
1298
1299int wl1271_debugfs_init(struct wl1271 *wl)
1300{
1301 int ret;
1302 struct dentry *rootdir;
1303
1304 rootdir = debugfs_create_dir(KBUILD_MODNAME,
1305 wl->hw->wiphy->debugfsdir);
1306
1307 wl->stats.fw_stats = kzalloc(wl->stats.fw_stats_len, GFP_KERNEL);
1308 if (!wl->stats.fw_stats) {
1309 ret = -ENOMEM;
1310 goto out_remove;
1311 }
1312
1313 wl->stats.fw_stats_update = jiffies;
1314
1315 wl1271_debugfs_add_files(wl, rootdir);
1316
1317 ret = wlcore_debugfs_init(wl, rootdir);
1318 if (ret < 0)
1319 goto out_exit;
1320
1321 goto out;
1322
1323out_exit:
1324 wl1271_debugfs_exit(wl);
1325
1326out_remove:
1327 debugfs_remove_recursive(rootdir);
1328
1329out:
1330 return ret;
1331}
1332
1333void wl1271_debugfs_exit(struct wl1271 *wl)
1334{
1335 kfree(wl->stats.fw_stats);
1336 wl->stats.fw_stats = NULL;
1337}