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