debugfs.c revision c7ffb902cca655e4d6bdda4156407008573bb214
1/* 2 * This file is part of wl1271 3 * 4 * Copyright (C) 2009 Nokia Corporation 5 * 6 * Contact: Luciano Coelho <luciano.coelho@nokia.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * version 2 as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 * 22 */ 23 24#include "debugfs.h" 25 26#include <linux/skbuff.h> 27#include <linux/slab.h> 28 29#include "wl12xx.h" 30#include "acx.h" 31#include "ps.h" 32#include "io.h" 33#include "tx.h" 34 35/* ms */ 36#define WL1271_DEBUGFS_STATS_LIFETIME 1000 37 38/* debugfs macros idea from mac80211 */ 39#define DEBUGFS_FORMAT_BUFFER_SIZE 100 40static int wl1271_format_buffer(char __user *userbuf, size_t count, 41 loff_t *ppos, char *fmt, ...) 42{ 43 va_list args; 44 char buf[DEBUGFS_FORMAT_BUFFER_SIZE]; 45 int res; 46 47 va_start(args, fmt); 48 res = vscnprintf(buf, sizeof(buf), fmt, args); 49 va_end(args); 50 51 return simple_read_from_buffer(userbuf, count, ppos, buf, res); 52} 53 54#define DEBUGFS_READONLY_FILE(name, fmt, value...) \ 55static ssize_t name## _read(struct file *file, char __user *userbuf, \ 56 size_t count, loff_t *ppos) \ 57{ \ 58 struct wl1271 *wl = file->private_data; \ 59 return wl1271_format_buffer(userbuf, count, ppos, \ 60 fmt "\n", ##value); \ 61} \ 62 \ 63static const struct file_operations name## _ops = { \ 64 .read = name## _read, \ 65 .open = wl1271_open_file_generic, \ 66 .llseek = generic_file_llseek, \ 67}; 68 69#define DEBUGFS_ADD(name, parent) \ 70 entry = debugfs_create_file(#name, 0400, parent, \ 71 wl, &name## _ops); \ 72 if (!entry || IS_ERR(entry)) \ 73 goto err; \ 74 75#define DEBUGFS_ADD_PREFIX(prefix, name, parent) \ 76 do { \ 77 entry = debugfs_create_file(#name, 0400, parent, \ 78 wl, &prefix## _## name## _ops); \ 79 if (!entry || IS_ERR(entry)) \ 80 goto err; \ 81 } while (0); 82 83#define DEBUGFS_FWSTATS_FILE(sub, name, fmt) \ 84static ssize_t sub## _ ##name## _read(struct file *file, \ 85 char __user *userbuf, \ 86 size_t count, loff_t *ppos) \ 87{ \ 88 struct wl1271 *wl = file->private_data; \ 89 \ 90 wl1271_debugfs_update_stats(wl); \ 91 \ 92 return wl1271_format_buffer(userbuf, count, ppos, fmt "\n", \ 93 wl->stats.fw_stats->sub.name); \ 94} \ 95 \ 96static const struct file_operations sub## _ ##name## _ops = { \ 97 .read = sub## _ ##name## _read, \ 98 .open = wl1271_open_file_generic, \ 99 .llseek = generic_file_llseek, \ 100}; 101 102#define DEBUGFS_FWSTATS_ADD(sub, name) \ 103 DEBUGFS_ADD(sub## _ ##name, stats) 104 105static void wl1271_debugfs_update_stats(struct wl1271 *wl) 106{ 107 int ret; 108 109 mutex_lock(&wl->mutex); 110 111 ret = wl1271_ps_elp_wakeup(wl); 112 if (ret < 0) 113 goto out; 114 115 if (wl->state == WL1271_STATE_ON && 116 time_after(jiffies, wl->stats.fw_stats_update + 117 msecs_to_jiffies(WL1271_DEBUGFS_STATS_LIFETIME))) { 118 wl1271_acx_statistics(wl, wl->stats.fw_stats); 119 wl->stats.fw_stats_update = jiffies; 120 } 121 122 wl1271_ps_elp_sleep(wl); 123 124out: 125 mutex_unlock(&wl->mutex); 126} 127 128static int wl1271_open_file_generic(struct inode *inode, struct file *file) 129{ 130 file->private_data = inode->i_private; 131 return 0; 132} 133 134DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, "%u"); 135 136DEBUGFS_FWSTATS_FILE(rx, out_of_mem, "%u"); 137DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, "%u"); 138DEBUGFS_FWSTATS_FILE(rx, hw_stuck, "%u"); 139DEBUGFS_FWSTATS_FILE(rx, dropped, "%u"); 140DEBUGFS_FWSTATS_FILE(rx, fcs_err, "%u"); 141DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, "%u"); 142DEBUGFS_FWSTATS_FILE(rx, path_reset, "%u"); 143DEBUGFS_FWSTATS_FILE(rx, reset_counter, "%u"); 144 145DEBUGFS_FWSTATS_FILE(dma, rx_requested, "%u"); 146DEBUGFS_FWSTATS_FILE(dma, rx_errors, "%u"); 147DEBUGFS_FWSTATS_FILE(dma, tx_requested, "%u"); 148DEBUGFS_FWSTATS_FILE(dma, tx_errors, "%u"); 149 150DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, "%u"); 151DEBUGFS_FWSTATS_FILE(isr, fiqs, "%u"); 152DEBUGFS_FWSTATS_FILE(isr, rx_headers, "%u"); 153DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, "%u"); 154DEBUGFS_FWSTATS_FILE(isr, rx_rdys, "%u"); 155DEBUGFS_FWSTATS_FILE(isr, irqs, "%u"); 156DEBUGFS_FWSTATS_FILE(isr, tx_procs, "%u"); 157DEBUGFS_FWSTATS_FILE(isr, decrypt_done, "%u"); 158DEBUGFS_FWSTATS_FILE(isr, dma0_done, "%u"); 159DEBUGFS_FWSTATS_FILE(isr, dma1_done, "%u"); 160DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, "%u"); 161DEBUGFS_FWSTATS_FILE(isr, commands, "%u"); 162DEBUGFS_FWSTATS_FILE(isr, rx_procs, "%u"); 163DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, "%u"); 164DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, "%u"); 165DEBUGFS_FWSTATS_FILE(isr, pci_pm, "%u"); 166DEBUGFS_FWSTATS_FILE(isr, wakeups, "%u"); 167DEBUGFS_FWSTATS_FILE(isr, low_rssi, "%u"); 168 169DEBUGFS_FWSTATS_FILE(wep, addr_key_count, "%u"); 170DEBUGFS_FWSTATS_FILE(wep, default_key_count, "%u"); 171/* skipping wep.reserved */ 172DEBUGFS_FWSTATS_FILE(wep, key_not_found, "%u"); 173DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, "%u"); 174DEBUGFS_FWSTATS_FILE(wep, packets, "%u"); 175DEBUGFS_FWSTATS_FILE(wep, interrupt, "%u"); 176 177DEBUGFS_FWSTATS_FILE(pwr, ps_enter, "%u"); 178DEBUGFS_FWSTATS_FILE(pwr, elp_enter, "%u"); 179DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, "%u"); 180DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, "%u"); 181DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, "%u"); 182DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, "%u"); 183DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, "%u"); 184DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, "%u"); 185DEBUGFS_FWSTATS_FILE(pwr, power_save_off, "%u"); 186DEBUGFS_FWSTATS_FILE(pwr, enable_ps, "%u"); 187DEBUGFS_FWSTATS_FILE(pwr, disable_ps, "%u"); 188DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, "%u"); 189/* skipping cont_miss_bcns_spread for now */ 190DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, "%u"); 191 192DEBUGFS_FWSTATS_FILE(mic, rx_pkts, "%u"); 193DEBUGFS_FWSTATS_FILE(mic, calc_failure, "%u"); 194 195DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, "%u"); 196DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, "%u"); 197DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, "%u"); 198DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, "%u"); 199DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, "%u"); 200DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, "%u"); 201 202DEBUGFS_FWSTATS_FILE(event, heart_beat, "%u"); 203DEBUGFS_FWSTATS_FILE(event, calibration, "%u"); 204DEBUGFS_FWSTATS_FILE(event, rx_mismatch, "%u"); 205DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, "%u"); 206DEBUGFS_FWSTATS_FILE(event, rx_pool, "%u"); 207DEBUGFS_FWSTATS_FILE(event, oom_late, "%u"); 208DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, "%u"); 209DEBUGFS_FWSTATS_FILE(event, tx_stuck, "%u"); 210 211DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, "%u"); 212DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, "%u"); 213DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, "%u"); 214DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, "%u"); 215DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, "%u"); 216DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, "%u"); 217DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, "%u"); 218 219DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, "%u"); 220DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, "%u"); 221DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data, "%u"); 222DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, "%u"); 223DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, "%u"); 224 225DEBUGFS_READONLY_FILE(retry_count, "%u", wl->stats.retry_count); 226DEBUGFS_READONLY_FILE(excessive_retries, "%u", 227 wl->stats.excessive_retries); 228 229static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf, 230 size_t count, loff_t *ppos) 231{ 232 struct wl1271 *wl = file->private_data; 233 u32 queue_len; 234 char buf[20]; 235 int res; 236 237 queue_len = wl1271_tx_total_queue_count(wl); 238 239 res = scnprintf(buf, sizeof(buf), "%u\n", queue_len); 240 return simple_read_from_buffer(userbuf, count, ppos, buf, res); 241} 242 243static const struct file_operations tx_queue_len_ops = { 244 .read = tx_queue_len_read, 245 .open = wl1271_open_file_generic, 246 .llseek = default_llseek, 247}; 248 249static ssize_t gpio_power_read(struct file *file, char __user *user_buf, 250 size_t count, loff_t *ppos) 251{ 252 struct wl1271 *wl = file->private_data; 253 bool state = test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags); 254 255 int res; 256 char buf[10]; 257 258 res = scnprintf(buf, sizeof(buf), "%d\n", state); 259 260 return simple_read_from_buffer(user_buf, count, ppos, buf, res); 261} 262 263static ssize_t gpio_power_write(struct file *file, 264 const char __user *user_buf, 265 size_t count, loff_t *ppos) 266{ 267 struct wl1271 *wl = file->private_data; 268 unsigned long value; 269 int ret; 270 271 ret = kstrtoul_from_user(user_buf, count, 10, &value); 272 if (ret < 0) { 273 wl1271_warning("illegal value in gpio_power"); 274 return -EINVAL; 275 } 276 277 mutex_lock(&wl->mutex); 278 279 if (value) 280 wl1271_power_on(wl); 281 else 282 wl1271_power_off(wl); 283 284 mutex_unlock(&wl->mutex); 285 return count; 286} 287 288static const struct file_operations gpio_power_ops = { 289 .read = gpio_power_read, 290 .write = gpio_power_write, 291 .open = wl1271_open_file_generic, 292 .llseek = default_llseek, 293}; 294 295static ssize_t start_recovery_write(struct file *file, 296 const char __user *user_buf, 297 size_t count, loff_t *ppos) 298{ 299 struct wl1271 *wl = file->private_data; 300 301 mutex_lock(&wl->mutex); 302 wl12xx_queue_recovery_work(wl); 303 mutex_unlock(&wl->mutex); 304 305 return count; 306} 307 308static const struct file_operations start_recovery_ops = { 309 .write = start_recovery_write, 310 .open = wl1271_open_file_generic, 311 .llseek = default_llseek, 312}; 313 314static ssize_t driver_state_read(struct file *file, char __user *user_buf, 315 size_t count, loff_t *ppos) 316{ 317 struct wl1271 *wl = file->private_data; 318 int res = 0; 319 char buf[1024]; 320 321 mutex_lock(&wl->mutex); 322 323#define DRIVER_STATE_PRINT(x, fmt) \ 324 (res += scnprintf(buf + res, sizeof(buf) - res,\ 325 #x " = " fmt "\n", wl->x)) 326 327#define DRIVER_STATE_PRINT_LONG(x) DRIVER_STATE_PRINT(x, "%ld") 328#define DRIVER_STATE_PRINT_INT(x) DRIVER_STATE_PRINT(x, "%d") 329#define DRIVER_STATE_PRINT_STR(x) DRIVER_STATE_PRINT(x, "%s") 330#define DRIVER_STATE_PRINT_LHEX(x) DRIVER_STATE_PRINT(x, "0x%lx") 331#define DRIVER_STATE_PRINT_HEX(x) DRIVER_STATE_PRINT(x, "0x%x") 332 333 DRIVER_STATE_PRINT_INT(tx_blocks_available); 334 DRIVER_STATE_PRINT_INT(tx_allocated_blocks); 335 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[0]); 336 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[1]); 337 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[2]); 338 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[3]); 339 DRIVER_STATE_PRINT_INT(tx_frames_cnt); 340 DRIVER_STATE_PRINT_LHEX(tx_frames_map[0]); 341 DRIVER_STATE_PRINT_INT(tx_queue_count[0]); 342 DRIVER_STATE_PRINT_INT(tx_queue_count[1]); 343 DRIVER_STATE_PRINT_INT(tx_queue_count[2]); 344 DRIVER_STATE_PRINT_INT(tx_queue_count[3]); 345 DRIVER_STATE_PRINT_INT(tx_packets_count); 346 DRIVER_STATE_PRINT_INT(tx_results_count); 347 DRIVER_STATE_PRINT_LHEX(flags); 348 DRIVER_STATE_PRINT_INT(tx_blocks_freed); 349 DRIVER_STATE_PRINT_INT(tx_security_last_seq_lsb); 350 DRIVER_STATE_PRINT_INT(rx_counter); 351 DRIVER_STATE_PRINT_INT(state); 352 DRIVER_STATE_PRINT_INT(channel); 353 DRIVER_STATE_PRINT_INT(band); 354 DRIVER_STATE_PRINT_INT(power_level); 355 DRIVER_STATE_PRINT_INT(sg_enabled); 356 DRIVER_STATE_PRINT_INT(enable_11a); 357 DRIVER_STATE_PRINT_INT(noise); 358 DRIVER_STATE_PRINT_INT(last_tx_hlid); 359 DRIVER_STATE_PRINT_HEX(ap_fw_ps_map); 360 DRIVER_STATE_PRINT_LHEX(ap_ps_map); 361 DRIVER_STATE_PRINT_HEX(quirks); 362 DRIVER_STATE_PRINT_HEX(irq); 363 DRIVER_STATE_PRINT_HEX(ref_clock); 364 DRIVER_STATE_PRINT_HEX(tcxo_clock); 365 DRIVER_STATE_PRINT_HEX(hw_pg_ver); 366 DRIVER_STATE_PRINT_HEX(platform_quirks); 367 DRIVER_STATE_PRINT_HEX(chip.id); 368 DRIVER_STATE_PRINT_STR(chip.fw_ver_str); 369 DRIVER_STATE_PRINT_INT(sched_scanning); 370 371#undef DRIVER_STATE_PRINT_INT 372#undef DRIVER_STATE_PRINT_LONG 373#undef DRIVER_STATE_PRINT_HEX 374#undef DRIVER_STATE_PRINT_LHEX 375#undef DRIVER_STATE_PRINT_STR 376#undef DRIVER_STATE_PRINT 377 378 mutex_unlock(&wl->mutex); 379 380 return simple_read_from_buffer(user_buf, count, ppos, buf, res); 381} 382 383static const struct file_operations driver_state_ops = { 384 .read = driver_state_read, 385 .open = wl1271_open_file_generic, 386 .llseek = default_llseek, 387}; 388 389static ssize_t dtim_interval_read(struct file *file, char __user *user_buf, 390 size_t count, loff_t *ppos) 391{ 392 struct wl1271 *wl = file->private_data; 393 u8 value; 394 395 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_DTIM || 396 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM) 397 value = wl->conf.conn.listen_interval; 398 else 399 value = 0; 400 401 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value); 402} 403 404static ssize_t dtim_interval_write(struct file *file, 405 const char __user *user_buf, 406 size_t count, loff_t *ppos) 407{ 408 struct wl1271 *wl = file->private_data; 409 unsigned long value; 410 int ret; 411 412 ret = kstrtoul_from_user(user_buf, count, 10, &value); 413 if (ret < 0) { 414 wl1271_warning("illegal value for dtim_interval"); 415 return -EINVAL; 416 } 417 418 if (value < 1 || value > 10) { 419 wl1271_warning("dtim value is not in valid range"); 420 return -ERANGE; 421 } 422 423 mutex_lock(&wl->mutex); 424 425 wl->conf.conn.listen_interval = value; 426 /* for some reason there are different event types for 1 and >1 */ 427 if (value == 1) 428 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_DTIM; 429 else 430 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM; 431 432 /* 433 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only 434 * take effect on the next time we enter psm. 435 */ 436 mutex_unlock(&wl->mutex); 437 return count; 438} 439 440static const struct file_operations dtim_interval_ops = { 441 .read = dtim_interval_read, 442 .write = dtim_interval_write, 443 .open = wl1271_open_file_generic, 444 .llseek = default_llseek, 445}; 446 447static ssize_t beacon_interval_read(struct file *file, char __user *user_buf, 448 size_t count, loff_t *ppos) 449{ 450 struct wl1271 *wl = file->private_data; 451 u8 value; 452 453 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_BEACON || 454 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_BEACONS) 455 value = wl->conf.conn.listen_interval; 456 else 457 value = 0; 458 459 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value); 460} 461 462static ssize_t beacon_interval_write(struct file *file, 463 const char __user *user_buf, 464 size_t count, loff_t *ppos) 465{ 466 struct wl1271 *wl = file->private_data; 467 unsigned long value; 468 int ret; 469 470 ret = kstrtoul_from_user(user_buf, count, 10, &value); 471 if (ret < 0) { 472 wl1271_warning("illegal value for beacon_interval"); 473 return -EINVAL; 474 } 475 476 if (value < 1 || value > 255) { 477 wl1271_warning("beacon interval value is not in valid range"); 478 return -ERANGE; 479 } 480 481 mutex_lock(&wl->mutex); 482 483 wl->conf.conn.listen_interval = value; 484 /* for some reason there are different event types for 1 and >1 */ 485 if (value == 1) 486 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_BEACON; 487 else 488 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_BEACONS; 489 490 /* 491 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only 492 * take effect on the next time we enter psm. 493 */ 494 mutex_unlock(&wl->mutex); 495 return count; 496} 497 498static const struct file_operations beacon_interval_ops = { 499 .read = beacon_interval_read, 500 .write = beacon_interval_write, 501 .open = wl1271_open_file_generic, 502 .llseek = default_llseek, 503}; 504 505static ssize_t rx_streaming_interval_write(struct file *file, 506 const char __user *user_buf, 507 size_t count, loff_t *ppos) 508{ 509 struct wl1271 *wl = file->private_data; 510 unsigned long value; 511 int ret; 512 513 ret = kstrtoul_from_user(user_buf, count, 10, &value); 514 if (ret < 0) { 515 wl1271_warning("illegal value in rx_streaming_interval!"); 516 return -EINVAL; 517 } 518 519 /* valid values: 0, 10-100 */ 520 if (value && (value < 10 || value > 100)) { 521 wl1271_warning("value is not in range!"); 522 return -ERANGE; 523 } 524 525 mutex_lock(&wl->mutex); 526 527 wl->conf.rx_streaming.interval = value; 528 529 ret = wl1271_ps_elp_wakeup(wl); 530 if (ret < 0) 531 goto out; 532 533 wl1271_recalc_rx_streaming(wl); 534 535 wl1271_ps_elp_sleep(wl); 536out: 537 mutex_unlock(&wl->mutex); 538 return count; 539} 540 541static ssize_t rx_streaming_interval_read(struct file *file, 542 char __user *userbuf, 543 size_t count, loff_t *ppos) 544{ 545 struct wl1271 *wl = file->private_data; 546 return wl1271_format_buffer(userbuf, count, ppos, 547 "%d\n", wl->conf.rx_streaming.interval); 548} 549 550static const struct file_operations rx_streaming_interval_ops = { 551 .read = rx_streaming_interval_read, 552 .write = rx_streaming_interval_write, 553 .open = wl1271_open_file_generic, 554 .llseek = default_llseek, 555}; 556 557static ssize_t rx_streaming_always_write(struct file *file, 558 const char __user *user_buf, 559 size_t count, loff_t *ppos) 560{ 561 struct wl1271 *wl = file->private_data; 562 unsigned long value; 563 int ret; 564 565 ret = kstrtoul_from_user(user_buf, count, 10, &value); 566 if (ret < 0) { 567 wl1271_warning("illegal value in rx_streaming_write!"); 568 return -EINVAL; 569 } 570 571 /* valid values: 0, 10-100 */ 572 if (!(value == 0 || value == 1)) { 573 wl1271_warning("value is not in valid!"); 574 return -EINVAL; 575 } 576 577 mutex_lock(&wl->mutex); 578 579 wl->conf.rx_streaming.always = value; 580 581 ret = wl1271_ps_elp_wakeup(wl); 582 if (ret < 0) 583 goto out; 584 585 wl1271_recalc_rx_streaming(wl); 586 587 wl1271_ps_elp_sleep(wl); 588out: 589 mutex_unlock(&wl->mutex); 590 return count; 591} 592 593static ssize_t rx_streaming_always_read(struct file *file, 594 char __user *userbuf, 595 size_t count, loff_t *ppos) 596{ 597 struct wl1271 *wl = file->private_data; 598 return wl1271_format_buffer(userbuf, count, ppos, 599 "%d\n", wl->conf.rx_streaming.always); 600} 601 602static const struct file_operations rx_streaming_always_ops = { 603 .read = rx_streaming_always_read, 604 .write = rx_streaming_always_write, 605 .open = wl1271_open_file_generic, 606 .llseek = default_llseek, 607}; 608 609static ssize_t beacon_filtering_write(struct file *file, 610 const char __user *user_buf, 611 size_t count, loff_t *ppos) 612{ 613 struct wl1271 *wl = file->private_data; 614 struct ieee80211_vif *vif; 615 struct wl12xx_vif *wlvif; 616 char buf[10]; 617 size_t len; 618 unsigned long value; 619 int ret; 620 621 if (!wl->vif) 622 return -EINVAL; 623 624 vif = wl->vif; 625 wlvif = wl12xx_vif_to_data(vif); 626 627 len = min(count, sizeof(buf) - 1); 628 if (copy_from_user(buf, user_buf, len)) 629 return -EFAULT; 630 buf[len] = '\0'; 631 632 ret = kstrtoul(buf, 0, &value); 633 if (ret < 0) { 634 wl1271_warning("illegal value for beacon_filtering!"); 635 return -EINVAL; 636 } 637 638 mutex_lock(&wl->mutex); 639 640 ret = wl1271_ps_elp_wakeup(wl); 641 if (ret < 0) 642 goto out; 643 644 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, !!value); 645 646 wl1271_ps_elp_sleep(wl); 647out: 648 mutex_unlock(&wl->mutex); 649 return count; 650} 651 652static const struct file_operations beacon_filtering_ops = { 653 .write = beacon_filtering_write, 654 .open = wl1271_open_file_generic, 655 .llseek = default_llseek, 656}; 657 658static int wl1271_debugfs_add_files(struct wl1271 *wl, 659 struct dentry *rootdir) 660{ 661 int ret = 0; 662 struct dentry *entry, *stats, *streaming; 663 664 stats = debugfs_create_dir("fw-statistics", rootdir); 665 if (!stats || IS_ERR(stats)) { 666 entry = stats; 667 goto err; 668 } 669 670 DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow); 671 672 DEBUGFS_FWSTATS_ADD(rx, out_of_mem); 673 DEBUGFS_FWSTATS_ADD(rx, hdr_overflow); 674 DEBUGFS_FWSTATS_ADD(rx, hw_stuck); 675 DEBUGFS_FWSTATS_ADD(rx, dropped); 676 DEBUGFS_FWSTATS_ADD(rx, fcs_err); 677 DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig); 678 DEBUGFS_FWSTATS_ADD(rx, path_reset); 679 DEBUGFS_FWSTATS_ADD(rx, reset_counter); 680 681 DEBUGFS_FWSTATS_ADD(dma, rx_requested); 682 DEBUGFS_FWSTATS_ADD(dma, rx_errors); 683 DEBUGFS_FWSTATS_ADD(dma, tx_requested); 684 DEBUGFS_FWSTATS_ADD(dma, tx_errors); 685 686 DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt); 687 DEBUGFS_FWSTATS_ADD(isr, fiqs); 688 DEBUGFS_FWSTATS_ADD(isr, rx_headers); 689 DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow); 690 DEBUGFS_FWSTATS_ADD(isr, rx_rdys); 691 DEBUGFS_FWSTATS_ADD(isr, irqs); 692 DEBUGFS_FWSTATS_ADD(isr, tx_procs); 693 DEBUGFS_FWSTATS_ADD(isr, decrypt_done); 694 DEBUGFS_FWSTATS_ADD(isr, dma0_done); 695 DEBUGFS_FWSTATS_ADD(isr, dma1_done); 696 DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete); 697 DEBUGFS_FWSTATS_ADD(isr, commands); 698 DEBUGFS_FWSTATS_ADD(isr, rx_procs); 699 DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes); 700 DEBUGFS_FWSTATS_ADD(isr, host_acknowledges); 701 DEBUGFS_FWSTATS_ADD(isr, pci_pm); 702 DEBUGFS_FWSTATS_ADD(isr, wakeups); 703 DEBUGFS_FWSTATS_ADD(isr, low_rssi); 704 705 DEBUGFS_FWSTATS_ADD(wep, addr_key_count); 706 DEBUGFS_FWSTATS_ADD(wep, default_key_count); 707 /* skipping wep.reserved */ 708 DEBUGFS_FWSTATS_ADD(wep, key_not_found); 709 DEBUGFS_FWSTATS_ADD(wep, decrypt_fail); 710 DEBUGFS_FWSTATS_ADD(wep, packets); 711 DEBUGFS_FWSTATS_ADD(wep, interrupt); 712 713 DEBUGFS_FWSTATS_ADD(pwr, ps_enter); 714 DEBUGFS_FWSTATS_ADD(pwr, elp_enter); 715 DEBUGFS_FWSTATS_ADD(pwr, missing_bcns); 716 DEBUGFS_FWSTATS_ADD(pwr, wake_on_host); 717 DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp); 718 DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps); 719 DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps); 720 DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons); 721 DEBUGFS_FWSTATS_ADD(pwr, power_save_off); 722 DEBUGFS_FWSTATS_ADD(pwr, enable_ps); 723 DEBUGFS_FWSTATS_ADD(pwr, disable_ps); 724 DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps); 725 /* skipping cont_miss_bcns_spread for now */ 726 DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons); 727 728 DEBUGFS_FWSTATS_ADD(mic, rx_pkts); 729 DEBUGFS_FWSTATS_ADD(mic, calc_failure); 730 731 DEBUGFS_FWSTATS_ADD(aes, encrypt_fail); 732 DEBUGFS_FWSTATS_ADD(aes, decrypt_fail); 733 DEBUGFS_FWSTATS_ADD(aes, encrypt_packets); 734 DEBUGFS_FWSTATS_ADD(aes, decrypt_packets); 735 DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt); 736 DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt); 737 738 DEBUGFS_FWSTATS_ADD(event, heart_beat); 739 DEBUGFS_FWSTATS_ADD(event, calibration); 740 DEBUGFS_FWSTATS_ADD(event, rx_mismatch); 741 DEBUGFS_FWSTATS_ADD(event, rx_mem_empty); 742 DEBUGFS_FWSTATS_ADD(event, rx_pool); 743 DEBUGFS_FWSTATS_ADD(event, oom_late); 744 DEBUGFS_FWSTATS_ADD(event, phy_transmit_error); 745 DEBUGFS_FWSTATS_ADD(event, tx_stuck); 746 747 DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts); 748 DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts); 749 DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime); 750 DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn); 751 DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn); 752 DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization); 753 DEBUGFS_FWSTATS_ADD(ps, upsd_utilization); 754 755 DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop); 756 DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data); 757 DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data); 758 DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data); 759 DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data); 760 761 DEBUGFS_ADD(tx_queue_len, rootdir); 762 DEBUGFS_ADD(retry_count, rootdir); 763 DEBUGFS_ADD(excessive_retries, rootdir); 764 765 DEBUGFS_ADD(gpio_power, rootdir); 766 DEBUGFS_ADD(start_recovery, rootdir); 767 DEBUGFS_ADD(driver_state, rootdir); 768 DEBUGFS_ADD(dtim_interval, rootdir); 769 DEBUGFS_ADD(beacon_interval, rootdir); 770 DEBUGFS_ADD(beacon_filtering, rootdir); 771 772 streaming = debugfs_create_dir("rx_streaming", rootdir); 773 if (!streaming || IS_ERR(streaming)) 774 goto err; 775 776 DEBUGFS_ADD_PREFIX(rx_streaming, interval, streaming); 777 DEBUGFS_ADD_PREFIX(rx_streaming, always, streaming); 778 779 780 return 0; 781 782err: 783 if (IS_ERR(entry)) 784 ret = PTR_ERR(entry); 785 else 786 ret = -ENOMEM; 787 788 return ret; 789} 790 791void wl1271_debugfs_reset(struct wl1271 *wl) 792{ 793 if (!wl->stats.fw_stats) 794 return; 795 796 memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats)); 797 wl->stats.retry_count = 0; 798 wl->stats.excessive_retries = 0; 799} 800 801int wl1271_debugfs_init(struct wl1271 *wl) 802{ 803 int ret; 804 struct dentry *rootdir; 805 806 rootdir = debugfs_create_dir(KBUILD_MODNAME, 807 wl->hw->wiphy->debugfsdir); 808 809 if (IS_ERR(rootdir)) { 810 ret = PTR_ERR(rootdir); 811 goto err; 812 } 813 814 wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats), 815 GFP_KERNEL); 816 817 if (!wl->stats.fw_stats) { 818 ret = -ENOMEM; 819 goto err_fw; 820 } 821 822 wl->stats.fw_stats_update = jiffies; 823 824 ret = wl1271_debugfs_add_files(wl, rootdir); 825 826 if (ret < 0) 827 goto err_file; 828 829 return 0; 830 831err_file: 832 kfree(wl->stats.fw_stats); 833 wl->stats.fw_stats = NULL; 834 835err_fw: 836 debugfs_remove_recursive(rootdir); 837 838err: 839 return ret; 840} 841 842void wl1271_debugfs_exit(struct wl1271 *wl) 843{ 844 kfree(wl->stats.fw_stats); 845 wl->stats.fw_stats = NULL; 846} 847