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 "wlcore.h" 30 #include "debug.h" 31 #include "acx.h" 32 #include "ps.h" 33 #include "io.h" 34 #include "tx.h" 35 36 /* ms */ 37 #define WL1271_DEBUGFS_STATS_LIFETIME 1000 38 39 /* debugfs macros idea from mac80211 */ 40 #define DEBUGFS_FORMAT_BUFFER_SIZE 100 41 static int wl1271_format_buffer(char __user *userbuf, size_t count, 42 loff_t *ppos, char *fmt, ...) 43 { 44 va_list args; 45 char buf[DEBUGFS_FORMAT_BUFFER_SIZE]; 46 int res; 47 48 va_start(args, fmt); 49 res = vscnprintf(buf, sizeof(buf), fmt, args); 50 va_end(args); 51 52 return simple_read_from_buffer(userbuf, count, ppos, buf, res); 53 } 54 55 #define DEBUGFS_READONLY_FILE(name, fmt, value...) \ 56 static ssize_t name## _read(struct file *file, char __user *userbuf, \ 57 size_t count, loff_t *ppos) \ 58 { \ 59 struct wl1271 *wl = file->private_data; \ 60 return wl1271_format_buffer(userbuf, count, ppos, \ 61 fmt "\n", ##value); \ 62 } \ 63 \ 64 static const struct file_operations name## _ops = { \ 65 .read = name## _read, \ 66 .open = simple_open, \ 67 .llseek = generic_file_llseek, \ 68 }; 69 70 #define DEBUGFS_ADD(name, parent) \ 71 entry = debugfs_create_file(#name, 0400, parent, \ 72 wl, &name## _ops); \ 73 if (!entry || IS_ERR(entry)) \ 74 goto err; \ 75 76 #define DEBUGFS_ADD_PREFIX(prefix, name, parent) \ 77 do { \ 78 entry = debugfs_create_file(#name, 0400, parent, \ 79 wl, &prefix## _## name## _ops); \ 80 if (!entry || IS_ERR(entry)) \ 81 goto err; \ 82 } while (0); 83 84 #define DEBUGFS_FWSTATS_FILE(sub, name, fmt) \ 85 static ssize_t sub## _ ##name## _read(struct file *file, \ 86 char __user *userbuf, \ 87 size_t count, loff_t *ppos) \ 88 { \ 89 struct wl1271 *wl = file->private_data; \ 90 \ 91 wl1271_debugfs_update_stats(wl); \ 92 \ 93 return wl1271_format_buffer(userbuf, count, ppos, fmt "\n", \ 94 wl->stats.fw_stats->sub.name); \ 95 } \ 96 \ 97 static const struct file_operations sub## _ ##name## _ops = { \ 98 .read = sub## _ ##name## _read, \ 99 .open = simple_open, \ 100 .llseek = generic_file_llseek, \ 101 }; 102 103 #define DEBUGFS_FWSTATS_ADD(sub, name) \ 104 DEBUGFS_ADD(sub## _ ##name, stats) 105 106 static void wl1271_debugfs_update_stats(struct wl1271 *wl) 107 { 108 int ret; 109 110 mutex_lock(&wl->mutex); 111 112 ret = wl1271_ps_elp_wakeup(wl); 113 if (ret < 0) 114 goto out; 115 116 if (wl->state == WL1271_STATE_ON && !wl->plt && 117 time_after(jiffies, wl->stats.fw_stats_update + 118 msecs_to_jiffies(WL1271_DEBUGFS_STATS_LIFETIME))) { 119 wl1271_acx_statistics(wl, wl->stats.fw_stats); 120 wl->stats.fw_stats_update = jiffies; 121 } 122 123 wl1271_ps_elp_sleep(wl); 124 125 out: 126 mutex_unlock(&wl->mutex); 127 } 128 129 DEBUGFS_FWSTATS_FILE(tx, internal_desc_overflow, "%u"); 130 131 DEBUGFS_FWSTATS_FILE(rx, out_of_mem, "%u"); 132 DEBUGFS_FWSTATS_FILE(rx, hdr_overflow, "%u"); 133 DEBUGFS_FWSTATS_FILE(rx, hw_stuck, "%u"); 134 DEBUGFS_FWSTATS_FILE(rx, dropped, "%u"); 135 DEBUGFS_FWSTATS_FILE(rx, fcs_err, "%u"); 136 DEBUGFS_FWSTATS_FILE(rx, xfr_hint_trig, "%u"); 137 DEBUGFS_FWSTATS_FILE(rx, path_reset, "%u"); 138 DEBUGFS_FWSTATS_FILE(rx, reset_counter, "%u"); 139 140 DEBUGFS_FWSTATS_FILE(dma, rx_requested, "%u"); 141 DEBUGFS_FWSTATS_FILE(dma, rx_errors, "%u"); 142 DEBUGFS_FWSTATS_FILE(dma, tx_requested, "%u"); 143 DEBUGFS_FWSTATS_FILE(dma, tx_errors, "%u"); 144 145 DEBUGFS_FWSTATS_FILE(isr, cmd_cmplt, "%u"); 146 DEBUGFS_FWSTATS_FILE(isr, fiqs, "%u"); 147 DEBUGFS_FWSTATS_FILE(isr, rx_headers, "%u"); 148 DEBUGFS_FWSTATS_FILE(isr, rx_mem_overflow, "%u"); 149 DEBUGFS_FWSTATS_FILE(isr, rx_rdys, "%u"); 150 DEBUGFS_FWSTATS_FILE(isr, irqs, "%u"); 151 DEBUGFS_FWSTATS_FILE(isr, tx_procs, "%u"); 152 DEBUGFS_FWSTATS_FILE(isr, decrypt_done, "%u"); 153 DEBUGFS_FWSTATS_FILE(isr, dma0_done, "%u"); 154 DEBUGFS_FWSTATS_FILE(isr, dma1_done, "%u"); 155 DEBUGFS_FWSTATS_FILE(isr, tx_exch_complete, "%u"); 156 DEBUGFS_FWSTATS_FILE(isr, commands, "%u"); 157 DEBUGFS_FWSTATS_FILE(isr, rx_procs, "%u"); 158 DEBUGFS_FWSTATS_FILE(isr, hw_pm_mode_changes, "%u"); 159 DEBUGFS_FWSTATS_FILE(isr, host_acknowledges, "%u"); 160 DEBUGFS_FWSTATS_FILE(isr, pci_pm, "%u"); 161 DEBUGFS_FWSTATS_FILE(isr, wakeups, "%u"); 162 DEBUGFS_FWSTATS_FILE(isr, low_rssi, "%u"); 163 164 DEBUGFS_FWSTATS_FILE(wep, addr_key_count, "%u"); 165 DEBUGFS_FWSTATS_FILE(wep, default_key_count, "%u"); 166 /* skipping wep.reserved */ 167 DEBUGFS_FWSTATS_FILE(wep, key_not_found, "%u"); 168 DEBUGFS_FWSTATS_FILE(wep, decrypt_fail, "%u"); 169 DEBUGFS_FWSTATS_FILE(wep, packets, "%u"); 170 DEBUGFS_FWSTATS_FILE(wep, interrupt, "%u"); 171 172 DEBUGFS_FWSTATS_FILE(pwr, ps_enter, "%u"); 173 DEBUGFS_FWSTATS_FILE(pwr, elp_enter, "%u"); 174 DEBUGFS_FWSTATS_FILE(pwr, missing_bcns, "%u"); 175 DEBUGFS_FWSTATS_FILE(pwr, wake_on_host, "%u"); 176 DEBUGFS_FWSTATS_FILE(pwr, wake_on_timer_exp, "%u"); 177 DEBUGFS_FWSTATS_FILE(pwr, tx_with_ps, "%u"); 178 DEBUGFS_FWSTATS_FILE(pwr, tx_without_ps, "%u"); 179 DEBUGFS_FWSTATS_FILE(pwr, rcvd_beacons, "%u"); 180 DEBUGFS_FWSTATS_FILE(pwr, power_save_off, "%u"); 181 DEBUGFS_FWSTATS_FILE(pwr, enable_ps, "%u"); 182 DEBUGFS_FWSTATS_FILE(pwr, disable_ps, "%u"); 183 DEBUGFS_FWSTATS_FILE(pwr, fix_tsf_ps, "%u"); 184 /* skipping cont_miss_bcns_spread for now */ 185 DEBUGFS_FWSTATS_FILE(pwr, rcvd_awake_beacons, "%u"); 186 187 DEBUGFS_FWSTATS_FILE(mic, rx_pkts, "%u"); 188 DEBUGFS_FWSTATS_FILE(mic, calc_failure, "%u"); 189 190 DEBUGFS_FWSTATS_FILE(aes, encrypt_fail, "%u"); 191 DEBUGFS_FWSTATS_FILE(aes, decrypt_fail, "%u"); 192 DEBUGFS_FWSTATS_FILE(aes, encrypt_packets, "%u"); 193 DEBUGFS_FWSTATS_FILE(aes, decrypt_packets, "%u"); 194 DEBUGFS_FWSTATS_FILE(aes, encrypt_interrupt, "%u"); 195 DEBUGFS_FWSTATS_FILE(aes, decrypt_interrupt, "%u"); 196 197 DEBUGFS_FWSTATS_FILE(event, heart_beat, "%u"); 198 DEBUGFS_FWSTATS_FILE(event, calibration, "%u"); 199 DEBUGFS_FWSTATS_FILE(event, rx_mismatch, "%u"); 200 DEBUGFS_FWSTATS_FILE(event, rx_mem_empty, "%u"); 201 DEBUGFS_FWSTATS_FILE(event, rx_pool, "%u"); 202 DEBUGFS_FWSTATS_FILE(event, oom_late, "%u"); 203 DEBUGFS_FWSTATS_FILE(event, phy_transmit_error, "%u"); 204 DEBUGFS_FWSTATS_FILE(event, tx_stuck, "%u"); 205 206 DEBUGFS_FWSTATS_FILE(ps, pspoll_timeouts, "%u"); 207 DEBUGFS_FWSTATS_FILE(ps, upsd_timeouts, "%u"); 208 DEBUGFS_FWSTATS_FILE(ps, upsd_max_sptime, "%u"); 209 DEBUGFS_FWSTATS_FILE(ps, upsd_max_apturn, "%u"); 210 DEBUGFS_FWSTATS_FILE(ps, pspoll_max_apturn, "%u"); 211 DEBUGFS_FWSTATS_FILE(ps, pspoll_utilization, "%u"); 212 DEBUGFS_FWSTATS_FILE(ps, upsd_utilization, "%u"); 213 214 DEBUGFS_FWSTATS_FILE(rxpipe, rx_prep_beacon_drop, "%u"); 215 DEBUGFS_FWSTATS_FILE(rxpipe, descr_host_int_trig_rx_data, "%u"); 216 DEBUGFS_FWSTATS_FILE(rxpipe, beacon_buffer_thres_host_int_trig_rx_data, "%u"); 217 DEBUGFS_FWSTATS_FILE(rxpipe, missed_beacon_host_int_trig_rx_data, "%u"); 218 DEBUGFS_FWSTATS_FILE(rxpipe, tx_xfr_host_int_trig_rx_data, "%u"); 219 220 DEBUGFS_READONLY_FILE(retry_count, "%u", wl->stats.retry_count); 221 DEBUGFS_READONLY_FILE(excessive_retries, "%u", 222 wl->stats.excessive_retries); 223 224 static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf, 225 size_t count, loff_t *ppos) 226 { 227 struct wl1271 *wl = file->private_data; 228 u32 queue_len; 229 char buf[20]; 230 int res; 231 232 queue_len = wl1271_tx_total_queue_count(wl); 233 234 res = scnprintf(buf, sizeof(buf), "%u\n", queue_len); 235 return simple_read_from_buffer(userbuf, count, ppos, buf, res); 236 } 237 238 static const struct file_operations tx_queue_len_ops = { 239 .read = tx_queue_len_read, 240 .open = simple_open, 241 .llseek = default_llseek, 242 }; 243 244 static ssize_t gpio_power_read(struct file *file, char __user *user_buf, 245 size_t count, loff_t *ppos) 246 { 247 struct wl1271 *wl = file->private_data; 248 bool state = test_bit(WL1271_FLAG_GPIO_POWER, &wl->flags); 249 250 int res; 251 char buf[10]; 252 253 res = scnprintf(buf, sizeof(buf), "%d\n", state); 254 255 return simple_read_from_buffer(user_buf, count, ppos, buf, res); 256 } 257 258 static ssize_t gpio_power_write(struct file *file, 259 const char __user *user_buf, 260 size_t count, loff_t *ppos) 261 { 262 struct wl1271 *wl = file->private_data; 263 unsigned long value; 264 int ret; 265 266 ret = kstrtoul_from_user(user_buf, count, 10, &value); 267 if (ret < 0) { 268 wl1271_warning("illegal value in gpio_power"); 269 return -EINVAL; 270 } 271 272 mutex_lock(&wl->mutex); 273 274 if (value) 275 wl1271_power_on(wl); 276 else 277 wl1271_power_off(wl); 278 279 mutex_unlock(&wl->mutex); 280 return count; 281 } 282 283 static const struct file_operations gpio_power_ops = { 284 .read = gpio_power_read, 285 .write = gpio_power_write, 286 .open = simple_open, 287 .llseek = default_llseek, 288 }; 289 290 static ssize_t start_recovery_write(struct file *file, 291 const char __user *user_buf, 292 size_t count, loff_t *ppos) 293 { 294 struct wl1271 *wl = file->private_data; 295 296 mutex_lock(&wl->mutex); 297 wl12xx_queue_recovery_work(wl); 298 mutex_unlock(&wl->mutex); 299 300 return count; 301 } 302 303 static const struct file_operations start_recovery_ops = { 304 .write = start_recovery_write, 305 .open = simple_open, 306 .llseek = default_llseek, 307 }; 308 309 static ssize_t dynamic_ps_timeout_read(struct file *file, char __user *user_buf, 310 size_t count, loff_t *ppos) 311 { 312 struct wl1271 *wl = file->private_data; 313 314 return wl1271_format_buffer(user_buf, count, 315 ppos, "%d\n", 316 wl->conf.conn.dynamic_ps_timeout); 317 } 318 319 static ssize_t dynamic_ps_timeout_write(struct file *file, 320 const char __user *user_buf, 321 size_t count, loff_t *ppos) 322 { 323 struct wl1271 *wl = file->private_data; 324 struct wl12xx_vif *wlvif; 325 unsigned long value; 326 int ret; 327 328 ret = kstrtoul_from_user(user_buf, count, 10, &value); 329 if (ret < 0) { 330 wl1271_warning("illegal value in dynamic_ps"); 331 return -EINVAL; 332 } 333 334 if (value < 1 || value > 65535) { 335 wl1271_warning("dyanmic_ps_timeout is not in valid range"); 336 return -ERANGE; 337 } 338 339 mutex_lock(&wl->mutex); 340 341 wl->conf.conn.dynamic_ps_timeout = value; 342 343 if (wl->state == WL1271_STATE_OFF) 344 goto out; 345 346 ret = wl1271_ps_elp_wakeup(wl); 347 if (ret < 0) 348 goto out; 349 350 /* In case we're already in PSM, trigger it again to set new timeout 351 * immediately without waiting for re-association 352 */ 353 354 wl12xx_for_each_wlvif_sta(wl, wlvif) { 355 if (test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) 356 wl1271_ps_set_mode(wl, wlvif, STATION_AUTO_PS_MODE); 357 } 358 359 wl1271_ps_elp_sleep(wl); 360 361 out: 362 mutex_unlock(&wl->mutex); 363 return count; 364 } 365 366 static const struct file_operations dynamic_ps_timeout_ops = { 367 .read = dynamic_ps_timeout_read, 368 .write = dynamic_ps_timeout_write, 369 .open = simple_open, 370 .llseek = default_llseek, 371 }; 372 373 static ssize_t forced_ps_read(struct file *file, char __user *user_buf, 374 size_t count, loff_t *ppos) 375 { 376 struct wl1271 *wl = file->private_data; 377 378 return wl1271_format_buffer(user_buf, count, 379 ppos, "%d\n", 380 wl->conf.conn.forced_ps); 381 } 382 383 static ssize_t forced_ps_write(struct file *file, 384 const char __user *user_buf, 385 size_t count, loff_t *ppos) 386 { 387 struct wl1271 *wl = file->private_data; 388 struct wl12xx_vif *wlvif; 389 unsigned long value; 390 int ret, ps_mode; 391 392 ret = kstrtoul_from_user(user_buf, count, 10, &value); 393 if (ret < 0) { 394 wl1271_warning("illegal value in forced_ps"); 395 return -EINVAL; 396 } 397 398 if (value != 1 && value != 0) { 399 wl1271_warning("forced_ps should be either 0 or 1"); 400 return -ERANGE; 401 } 402 403 mutex_lock(&wl->mutex); 404 405 if (wl->conf.conn.forced_ps == value) 406 goto out; 407 408 wl->conf.conn.forced_ps = value; 409 410 if (wl->state == WL1271_STATE_OFF) 411 goto out; 412 413 ret = wl1271_ps_elp_wakeup(wl); 414 if (ret < 0) 415 goto out; 416 417 /* In case we're already in PSM, trigger it again to switch mode 418 * immediately without waiting for re-association 419 */ 420 421 ps_mode = value ? STATION_POWER_SAVE_MODE : STATION_AUTO_PS_MODE; 422 423 wl12xx_for_each_wlvif_sta(wl, wlvif) { 424 if (test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) 425 wl1271_ps_set_mode(wl, wlvif, ps_mode); 426 } 427 428 wl1271_ps_elp_sleep(wl); 429 430 out: 431 mutex_unlock(&wl->mutex); 432 return count; 433 } 434 435 static const struct file_operations forced_ps_ops = { 436 .read = forced_ps_read, 437 .write = forced_ps_write, 438 .open = simple_open, 439 .llseek = default_llseek, 440 }; 441 442 static ssize_t split_scan_timeout_read(struct file *file, char __user *user_buf, 443 size_t count, loff_t *ppos) 444 { 445 struct wl1271 *wl = file->private_data; 446 447 return wl1271_format_buffer(user_buf, count, 448 ppos, "%d\n", 449 wl->conf.scan.split_scan_timeout / 1000); 450 } 451 452 static ssize_t split_scan_timeout_write(struct file *file, 453 const char __user *user_buf, 454 size_t count, loff_t *ppos) 455 { 456 struct wl1271 *wl = file->private_data; 457 unsigned long value; 458 int ret; 459 460 ret = kstrtoul_from_user(user_buf, count, 10, &value); 461 if (ret < 0) { 462 wl1271_warning("illegal value in split_scan_timeout"); 463 return -EINVAL; 464 } 465 466 if (value == 0) 467 wl1271_info("split scan will be disabled"); 468 469 mutex_lock(&wl->mutex); 470 471 wl->conf.scan.split_scan_timeout = value * 1000; 472 473 mutex_unlock(&wl->mutex); 474 return count; 475 } 476 477 static const struct file_operations split_scan_timeout_ops = { 478 .read = split_scan_timeout_read, 479 .write = split_scan_timeout_write, 480 .open = simple_open, 481 .llseek = default_llseek, 482 }; 483 484 static ssize_t driver_state_read(struct file *file, char __user *user_buf, 485 size_t count, loff_t *ppos) 486 { 487 struct wl1271 *wl = file->private_data; 488 int res = 0; 489 ssize_t ret; 490 char *buf; 491 492 #define DRIVER_STATE_BUF_LEN 1024 493 494 buf = kmalloc(DRIVER_STATE_BUF_LEN, GFP_KERNEL); 495 if (!buf) 496 return -ENOMEM; 497 498 mutex_lock(&wl->mutex); 499 500 #define DRIVER_STATE_PRINT(x, fmt) \ 501 (res += scnprintf(buf + res, DRIVER_STATE_BUF_LEN - res,\ 502 #x " = " fmt "\n", wl->x)) 503 504 #define DRIVER_STATE_PRINT_LONG(x) DRIVER_STATE_PRINT(x, "%ld") 505 #define DRIVER_STATE_PRINT_INT(x) DRIVER_STATE_PRINT(x, "%d") 506 #define DRIVER_STATE_PRINT_STR(x) DRIVER_STATE_PRINT(x, "%s") 507 #define DRIVER_STATE_PRINT_LHEX(x) DRIVER_STATE_PRINT(x, "0x%lx") 508 #define DRIVER_STATE_PRINT_HEX(x) DRIVER_STATE_PRINT(x, "0x%x") 509 510 DRIVER_STATE_PRINT_INT(tx_blocks_available); 511 DRIVER_STATE_PRINT_INT(tx_allocated_blocks); 512 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[0]); 513 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[1]); 514 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[2]); 515 DRIVER_STATE_PRINT_INT(tx_allocated_pkts[3]); 516 DRIVER_STATE_PRINT_INT(tx_frames_cnt); 517 DRIVER_STATE_PRINT_LHEX(tx_frames_map[0]); 518 DRIVER_STATE_PRINT_INT(tx_queue_count[0]); 519 DRIVER_STATE_PRINT_INT(tx_queue_count[1]); 520 DRIVER_STATE_PRINT_INT(tx_queue_count[2]); 521 DRIVER_STATE_PRINT_INT(tx_queue_count[3]); 522 DRIVER_STATE_PRINT_INT(tx_packets_count); 523 DRIVER_STATE_PRINT_INT(tx_results_count); 524 DRIVER_STATE_PRINT_LHEX(flags); 525 DRIVER_STATE_PRINT_INT(tx_blocks_freed); 526 DRIVER_STATE_PRINT_INT(rx_counter); 527 DRIVER_STATE_PRINT_INT(state); 528 DRIVER_STATE_PRINT_INT(channel); 529 DRIVER_STATE_PRINT_INT(band); 530 DRIVER_STATE_PRINT_INT(power_level); 531 DRIVER_STATE_PRINT_INT(sg_enabled); 532 DRIVER_STATE_PRINT_INT(enable_11a); 533 DRIVER_STATE_PRINT_INT(noise); 534 DRIVER_STATE_PRINT_HEX(ap_fw_ps_map); 535 DRIVER_STATE_PRINT_LHEX(ap_ps_map); 536 DRIVER_STATE_PRINT_HEX(quirks); 537 DRIVER_STATE_PRINT_HEX(irq); 538 DRIVER_STATE_PRINT_HEX(ref_clock); 539 DRIVER_STATE_PRINT_HEX(tcxo_clock); 540 DRIVER_STATE_PRINT_HEX(hw_pg_ver); 541 DRIVER_STATE_PRINT_HEX(platform_quirks); 542 DRIVER_STATE_PRINT_HEX(chip.id); 543 DRIVER_STATE_PRINT_STR(chip.fw_ver_str); 544 DRIVER_STATE_PRINT_INT(sched_scanning); 545 546 #undef DRIVER_STATE_PRINT_INT 547 #undef DRIVER_STATE_PRINT_LONG 548 #undef DRIVER_STATE_PRINT_HEX 549 #undef DRIVER_STATE_PRINT_LHEX 550 #undef DRIVER_STATE_PRINT_STR 551 #undef DRIVER_STATE_PRINT 552 #undef DRIVER_STATE_BUF_LEN 553 554 mutex_unlock(&wl->mutex); 555 556 ret = simple_read_from_buffer(user_buf, count, ppos, buf, res); 557 kfree(buf); 558 return ret; 559 } 560 561 static const struct file_operations driver_state_ops = { 562 .read = driver_state_read, 563 .open = simple_open, 564 .llseek = default_llseek, 565 }; 566 567 static ssize_t vifs_state_read(struct file *file, char __user *user_buf, 568 size_t count, loff_t *ppos) 569 { 570 struct wl1271 *wl = file->private_data; 571 struct wl12xx_vif *wlvif; 572 int ret, res = 0; 573 const int buf_size = 4096; 574 char *buf; 575 char tmp_buf[64]; 576 577 buf = kzalloc(buf_size, GFP_KERNEL); 578 if (!buf) 579 return -ENOMEM; 580 581 mutex_lock(&wl->mutex); 582 583 #define VIF_STATE_PRINT(x, fmt) \ 584 (res += scnprintf(buf + res, buf_size - res, \ 585 #x " = " fmt "\n", wlvif->x)) 586 587 #define VIF_STATE_PRINT_LONG(x) VIF_STATE_PRINT(x, "%ld") 588 #define VIF_STATE_PRINT_INT(x) VIF_STATE_PRINT(x, "%d") 589 #define VIF_STATE_PRINT_STR(x) VIF_STATE_PRINT(x, "%s") 590 #define VIF_STATE_PRINT_LHEX(x) VIF_STATE_PRINT(x, "0x%lx") 591 #define VIF_STATE_PRINT_LLHEX(x) VIF_STATE_PRINT(x, "0x%llx") 592 #define VIF_STATE_PRINT_HEX(x) VIF_STATE_PRINT(x, "0x%x") 593 594 #define VIF_STATE_PRINT_NSTR(x, len) \ 595 do { \ 596 memset(tmp_buf, 0, sizeof(tmp_buf)); \ 597 memcpy(tmp_buf, wlvif->x, \ 598 min_t(u8, len, sizeof(tmp_buf) - 1)); \ 599 res += scnprintf(buf + res, buf_size - res, \ 600 #x " = %s\n", tmp_buf); \ 601 } while (0) 602 603 wl12xx_for_each_wlvif(wl, wlvif) { 604 VIF_STATE_PRINT_INT(role_id); 605 VIF_STATE_PRINT_INT(bss_type); 606 VIF_STATE_PRINT_LHEX(flags); 607 VIF_STATE_PRINT_INT(p2p); 608 VIF_STATE_PRINT_INT(dev_role_id); 609 VIF_STATE_PRINT_INT(dev_hlid); 610 611 if (wlvif->bss_type == BSS_TYPE_STA_BSS || 612 wlvif->bss_type == BSS_TYPE_IBSS) { 613 VIF_STATE_PRINT_INT(sta.hlid); 614 VIF_STATE_PRINT_INT(sta.ba_rx_bitmap); 615 VIF_STATE_PRINT_INT(sta.basic_rate_idx); 616 VIF_STATE_PRINT_INT(sta.ap_rate_idx); 617 VIF_STATE_PRINT_INT(sta.p2p_rate_idx); 618 VIF_STATE_PRINT_INT(sta.qos); 619 } else { 620 VIF_STATE_PRINT_INT(ap.global_hlid); 621 VIF_STATE_PRINT_INT(ap.bcast_hlid); 622 VIF_STATE_PRINT_LHEX(ap.sta_hlid_map[0]); 623 VIF_STATE_PRINT_INT(ap.mgmt_rate_idx); 624 VIF_STATE_PRINT_INT(ap.bcast_rate_idx); 625 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[0]); 626 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[1]); 627 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[2]); 628 VIF_STATE_PRINT_INT(ap.ucast_rate_idx[3]); 629 } 630 VIF_STATE_PRINT_INT(last_tx_hlid); 631 VIF_STATE_PRINT_LHEX(links_map[0]); 632 VIF_STATE_PRINT_NSTR(ssid, wlvif->ssid_len); 633 VIF_STATE_PRINT_INT(band); 634 VIF_STATE_PRINT_INT(channel); 635 VIF_STATE_PRINT_HEX(bitrate_masks[0]); 636 VIF_STATE_PRINT_HEX(bitrate_masks[1]); 637 VIF_STATE_PRINT_HEX(basic_rate_set); 638 VIF_STATE_PRINT_HEX(basic_rate); 639 VIF_STATE_PRINT_HEX(rate_set); 640 VIF_STATE_PRINT_INT(beacon_int); 641 VIF_STATE_PRINT_INT(default_key); 642 VIF_STATE_PRINT_INT(aid); 643 VIF_STATE_PRINT_INT(session_counter); 644 VIF_STATE_PRINT_INT(psm_entry_retry); 645 VIF_STATE_PRINT_INT(power_level); 646 VIF_STATE_PRINT_INT(rssi_thold); 647 VIF_STATE_PRINT_INT(last_rssi_event); 648 VIF_STATE_PRINT_INT(ba_support); 649 VIF_STATE_PRINT_INT(ba_allowed); 650 VIF_STATE_PRINT_INT(is_gem); 651 VIF_STATE_PRINT_LLHEX(tx_security_seq); 652 VIF_STATE_PRINT_INT(tx_security_last_seq_lsb); 653 } 654 655 #undef VIF_STATE_PRINT_INT 656 #undef VIF_STATE_PRINT_LONG 657 #undef VIF_STATE_PRINT_HEX 658 #undef VIF_STATE_PRINT_LHEX 659 #undef VIF_STATE_PRINT_LLHEX 660 #undef VIF_STATE_PRINT_STR 661 #undef VIF_STATE_PRINT_NSTR 662 #undef VIF_STATE_PRINT 663 664 mutex_unlock(&wl->mutex); 665 666 ret = simple_read_from_buffer(user_buf, count, ppos, buf, res); 667 kfree(buf); 668 return ret; 669 } 670 671 static const struct file_operations vifs_state_ops = { 672 .read = vifs_state_read, 673 .open = simple_open, 674 .llseek = default_llseek, 675 }; 676 677 static ssize_t dtim_interval_read(struct file *file, char __user *user_buf, 678 size_t count, loff_t *ppos) 679 { 680 struct wl1271 *wl = file->private_data; 681 u8 value; 682 683 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_DTIM || 684 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM) 685 value = wl->conf.conn.listen_interval; 686 else 687 value = 0; 688 689 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value); 690 } 691 692 static ssize_t dtim_interval_write(struct file *file, 693 const char __user *user_buf, 694 size_t count, loff_t *ppos) 695 { 696 struct wl1271 *wl = file->private_data; 697 unsigned long value; 698 int ret; 699 700 ret = kstrtoul_from_user(user_buf, count, 10, &value); 701 if (ret < 0) { 702 wl1271_warning("illegal value for dtim_interval"); 703 return -EINVAL; 704 } 705 706 if (value < 1 || value > 10) { 707 wl1271_warning("dtim value is not in valid range"); 708 return -ERANGE; 709 } 710 711 mutex_lock(&wl->mutex); 712 713 wl->conf.conn.listen_interval = value; 714 /* for some reason there are different event types for 1 and >1 */ 715 if (value == 1) 716 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_DTIM; 717 else 718 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM; 719 720 /* 721 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only 722 * take effect on the next time we enter psm. 723 */ 724 mutex_unlock(&wl->mutex); 725 return count; 726 } 727 728 static const struct file_operations dtim_interval_ops = { 729 .read = dtim_interval_read, 730 .write = dtim_interval_write, 731 .open = simple_open, 732 .llseek = default_llseek, 733 }; 734 735 736 737 static ssize_t suspend_dtim_interval_read(struct file *file, 738 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.suspend_wake_up_event == CONF_WAKE_UP_EVENT_DTIM || 745 wl->conf.conn.suspend_wake_up_event == CONF_WAKE_UP_EVENT_N_DTIM) 746 value = wl->conf.conn.suspend_listen_interval; 747 else 748 value = 0; 749 750 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value); 751 } 752 753 static ssize_t suspend_dtim_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 suspend_dtim_interval"); 764 return -EINVAL; 765 } 766 767 if (value < 1 || value > 10) { 768 wl1271_warning("suspend_dtim value is not in valid range"); 769 return -ERANGE; 770 } 771 772 mutex_lock(&wl->mutex); 773 774 wl->conf.conn.suspend_listen_interval = value; 775 /* for some reason there are different event types for 1 and >1 */ 776 if (value == 1) 777 wl->conf.conn.suspend_wake_up_event = CONF_WAKE_UP_EVENT_DTIM; 778 else 779 wl->conf.conn.suspend_wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM; 780 781 mutex_unlock(&wl->mutex); 782 return count; 783 } 784 785 786 static const struct file_operations suspend_dtim_interval_ops = { 787 .read = suspend_dtim_interval_read, 788 .write = suspend_dtim_interval_write, 789 .open = simple_open, 790 .llseek = default_llseek, 791 }; 792 793 static ssize_t beacon_interval_read(struct file *file, char __user *user_buf, 794 size_t count, loff_t *ppos) 795 { 796 struct wl1271 *wl = file->private_data; 797 u8 value; 798 799 if (wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_BEACON || 800 wl->conf.conn.wake_up_event == CONF_WAKE_UP_EVENT_N_BEACONS) 801 value = wl->conf.conn.listen_interval; 802 else 803 value = 0; 804 805 return wl1271_format_buffer(user_buf, count, ppos, "%d\n", value); 806 } 807 808 static ssize_t beacon_interval_write(struct file *file, 809 const char __user *user_buf, 810 size_t count, loff_t *ppos) 811 { 812 struct wl1271 *wl = file->private_data; 813 unsigned long value; 814 int ret; 815 816 ret = kstrtoul_from_user(user_buf, count, 10, &value); 817 if (ret < 0) { 818 wl1271_warning("illegal value for beacon_interval"); 819 return -EINVAL; 820 } 821 822 if (value < 1 || value > 255) { 823 wl1271_warning("beacon interval value is not in valid range"); 824 return -ERANGE; 825 } 826 827 mutex_lock(&wl->mutex); 828 829 wl->conf.conn.listen_interval = value; 830 /* for some reason there are different event types for 1 and >1 */ 831 if (value == 1) 832 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_BEACON; 833 else 834 wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_BEACONS; 835 836 /* 837 * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only 838 * take effect on the next time we enter psm. 839 */ 840 mutex_unlock(&wl->mutex); 841 return count; 842 } 843 844 static const struct file_operations beacon_interval_ops = { 845 .read = beacon_interval_read, 846 .write = beacon_interval_write, 847 .open = simple_open, 848 .llseek = default_llseek, 849 }; 850 851 static ssize_t rx_streaming_interval_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_interval!"); 863 return -EINVAL; 864 } 865 866 /* valid values: 0, 10-100 */ 867 if (value && (value < 10 || value > 100)) { 868 wl1271_warning("value is not in range!"); 869 return -ERANGE; 870 } 871 872 mutex_lock(&wl->mutex); 873 874 wl->conf.rx_streaming.interval = value; 875 876 ret = wl1271_ps_elp_wakeup(wl); 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 wl1271_ps_elp_sleep(wl); 885 out: 886 mutex_unlock(&wl->mutex); 887 return count; 888 } 889 890 static ssize_t rx_streaming_interval_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.interval); 897 } 898 899 static const struct file_operations rx_streaming_interval_ops = { 900 .read = rx_streaming_interval_read, 901 .write = rx_streaming_interval_write, 902 .open = simple_open, 903 .llseek = default_llseek, 904 }; 905 906 static ssize_t rx_streaming_always_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, 10, &value); 916 if (ret < 0) { 917 wl1271_warning("illegal value in rx_streaming_write!"); 918 return -EINVAL; 919 } 920 921 /* valid values: 0, 10-100 */ 922 if (!(value == 0 || value == 1)) { 923 wl1271_warning("value is not in valid!"); 924 return -EINVAL; 925 } 926 927 mutex_lock(&wl->mutex); 928 929 wl->conf.rx_streaming.always = value; 930 931 ret = wl1271_ps_elp_wakeup(wl); 932 if (ret < 0) 933 goto out; 934 935 wl12xx_for_each_wlvif_sta(wl, wlvif) { 936 wl1271_recalc_rx_streaming(wl, wlvif); 937 } 938 939 wl1271_ps_elp_sleep(wl); 940 out: 941 mutex_unlock(&wl->mutex); 942 return count; 943 } 944 945 static ssize_t rx_streaming_always_read(struct file *file, 946 char __user *userbuf, 947 size_t count, loff_t *ppos) 948 { 949 struct wl1271 *wl = file->private_data; 950 return wl1271_format_buffer(userbuf, count, ppos, 951 "%d\n", wl->conf.rx_streaming.always); 952 } 953 954 static const struct file_operations rx_streaming_always_ops = { 955 .read = rx_streaming_always_read, 956 .write = rx_streaming_always_write, 957 .open = simple_open, 958 .llseek = default_llseek, 959 }; 960 961 static ssize_t beacon_filtering_write(struct file *file, 962 const char __user *user_buf, 963 size_t count, loff_t *ppos) 964 { 965 struct wl1271 *wl = file->private_data; 966 struct wl12xx_vif *wlvif; 967 char buf[10]; 968 size_t len; 969 unsigned long value; 970 int ret; 971 972 len = min(count, sizeof(buf) - 1); 973 if (copy_from_user(buf, user_buf, len)) 974 return -EFAULT; 975 buf[len] = '\0'; 976 977 ret = kstrtoul(buf, 0, &value); 978 if (ret < 0) { 979 wl1271_warning("illegal value for beacon_filtering!"); 980 return -EINVAL; 981 } 982 983 mutex_lock(&wl->mutex); 984 985 ret = wl1271_ps_elp_wakeup(wl); 986 if (ret < 0) 987 goto out; 988 989 wl12xx_for_each_wlvif(wl, wlvif) { 990 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, !!value); 991 } 992 993 wl1271_ps_elp_sleep(wl); 994 out: 995 mutex_unlock(&wl->mutex); 996 return count; 997 } 998 999 static const struct file_operations beacon_filtering_ops = { 1000 .write = beacon_filtering_write, 1001 .open = simple_open, 1002 .llseek = default_llseek, 1003 }; 1004 1005 static int wl1271_debugfs_add_files(struct wl1271 *wl, 1006 struct dentry *rootdir) 1007 { 1008 int ret = 0; 1009 struct dentry *entry, *stats, *streaming; 1010 1011 stats = debugfs_create_dir("fw-statistics", rootdir); 1012 if (!stats || IS_ERR(stats)) { 1013 entry = stats; 1014 goto err; 1015 } 1016 1017 DEBUGFS_FWSTATS_ADD(tx, internal_desc_overflow); 1018 1019 DEBUGFS_FWSTATS_ADD(rx, out_of_mem); 1020 DEBUGFS_FWSTATS_ADD(rx, hdr_overflow); 1021 DEBUGFS_FWSTATS_ADD(rx, hw_stuck); 1022 DEBUGFS_FWSTATS_ADD(rx, dropped); 1023 DEBUGFS_FWSTATS_ADD(rx, fcs_err); 1024 DEBUGFS_FWSTATS_ADD(rx, xfr_hint_trig); 1025 DEBUGFS_FWSTATS_ADD(rx, path_reset); 1026 DEBUGFS_FWSTATS_ADD(rx, reset_counter); 1027 1028 DEBUGFS_FWSTATS_ADD(dma, rx_requested); 1029 DEBUGFS_FWSTATS_ADD(dma, rx_errors); 1030 DEBUGFS_FWSTATS_ADD(dma, tx_requested); 1031 DEBUGFS_FWSTATS_ADD(dma, tx_errors); 1032 1033 DEBUGFS_FWSTATS_ADD(isr, cmd_cmplt); 1034 DEBUGFS_FWSTATS_ADD(isr, fiqs); 1035 DEBUGFS_FWSTATS_ADD(isr, rx_headers); 1036 DEBUGFS_FWSTATS_ADD(isr, rx_mem_overflow); 1037 DEBUGFS_FWSTATS_ADD(isr, rx_rdys); 1038 DEBUGFS_FWSTATS_ADD(isr, irqs); 1039 DEBUGFS_FWSTATS_ADD(isr, tx_procs); 1040 DEBUGFS_FWSTATS_ADD(isr, decrypt_done); 1041 DEBUGFS_FWSTATS_ADD(isr, dma0_done); 1042 DEBUGFS_FWSTATS_ADD(isr, dma1_done); 1043 DEBUGFS_FWSTATS_ADD(isr, tx_exch_complete); 1044 DEBUGFS_FWSTATS_ADD(isr, commands); 1045 DEBUGFS_FWSTATS_ADD(isr, rx_procs); 1046 DEBUGFS_FWSTATS_ADD(isr, hw_pm_mode_changes); 1047 DEBUGFS_FWSTATS_ADD(isr, host_acknowledges); 1048 DEBUGFS_FWSTATS_ADD(isr, pci_pm); 1049 DEBUGFS_FWSTATS_ADD(isr, wakeups); 1050 DEBUGFS_FWSTATS_ADD(isr, low_rssi); 1051 1052 DEBUGFS_FWSTATS_ADD(wep, addr_key_count); 1053 DEBUGFS_FWSTATS_ADD(wep, default_key_count); 1054 /* skipping wep.reserved */ 1055 DEBUGFS_FWSTATS_ADD(wep, key_not_found); 1056 DEBUGFS_FWSTATS_ADD(wep, decrypt_fail); 1057 DEBUGFS_FWSTATS_ADD(wep, packets); 1058 DEBUGFS_FWSTATS_ADD(wep, interrupt); 1059 1060 DEBUGFS_FWSTATS_ADD(pwr, ps_enter); 1061 DEBUGFS_FWSTATS_ADD(pwr, elp_enter); 1062 DEBUGFS_FWSTATS_ADD(pwr, missing_bcns); 1063 DEBUGFS_FWSTATS_ADD(pwr, wake_on_host); 1064 DEBUGFS_FWSTATS_ADD(pwr, wake_on_timer_exp); 1065 DEBUGFS_FWSTATS_ADD(pwr, tx_with_ps); 1066 DEBUGFS_FWSTATS_ADD(pwr, tx_without_ps); 1067 DEBUGFS_FWSTATS_ADD(pwr, rcvd_beacons); 1068 DEBUGFS_FWSTATS_ADD(pwr, power_save_off); 1069 DEBUGFS_FWSTATS_ADD(pwr, enable_ps); 1070 DEBUGFS_FWSTATS_ADD(pwr, disable_ps); 1071 DEBUGFS_FWSTATS_ADD(pwr, fix_tsf_ps); 1072 /* skipping cont_miss_bcns_spread for now */ 1073 DEBUGFS_FWSTATS_ADD(pwr, rcvd_awake_beacons); 1074 1075 DEBUGFS_FWSTATS_ADD(mic, rx_pkts); 1076 DEBUGFS_FWSTATS_ADD(mic, calc_failure); 1077 1078 DEBUGFS_FWSTATS_ADD(aes, encrypt_fail); 1079 DEBUGFS_FWSTATS_ADD(aes, decrypt_fail); 1080 DEBUGFS_FWSTATS_ADD(aes, encrypt_packets); 1081 DEBUGFS_FWSTATS_ADD(aes, decrypt_packets); 1082 DEBUGFS_FWSTATS_ADD(aes, encrypt_interrupt); 1083 DEBUGFS_FWSTATS_ADD(aes, decrypt_interrupt); 1084 1085 DEBUGFS_FWSTATS_ADD(event, heart_beat); 1086 DEBUGFS_FWSTATS_ADD(event, calibration); 1087 DEBUGFS_FWSTATS_ADD(event, rx_mismatch); 1088 DEBUGFS_FWSTATS_ADD(event, rx_mem_empty); 1089 DEBUGFS_FWSTATS_ADD(event, rx_pool); 1090 DEBUGFS_FWSTATS_ADD(event, oom_late); 1091 DEBUGFS_FWSTATS_ADD(event, phy_transmit_error); 1092 DEBUGFS_FWSTATS_ADD(event, tx_stuck); 1093 1094 DEBUGFS_FWSTATS_ADD(ps, pspoll_timeouts); 1095 DEBUGFS_FWSTATS_ADD(ps, upsd_timeouts); 1096 DEBUGFS_FWSTATS_ADD(ps, upsd_max_sptime); 1097 DEBUGFS_FWSTATS_ADD(ps, upsd_max_apturn); 1098 DEBUGFS_FWSTATS_ADD(ps, pspoll_max_apturn); 1099 DEBUGFS_FWSTATS_ADD(ps, pspoll_utilization); 1100 DEBUGFS_FWSTATS_ADD(ps, upsd_utilization); 1101 1102 DEBUGFS_FWSTATS_ADD(rxpipe, rx_prep_beacon_drop); 1103 DEBUGFS_FWSTATS_ADD(rxpipe, descr_host_int_trig_rx_data); 1104 DEBUGFS_FWSTATS_ADD(rxpipe, beacon_buffer_thres_host_int_trig_rx_data); 1105 DEBUGFS_FWSTATS_ADD(rxpipe, missed_beacon_host_int_trig_rx_data); 1106 DEBUGFS_FWSTATS_ADD(rxpipe, tx_xfr_host_int_trig_rx_data); 1107 1108 DEBUGFS_ADD(tx_queue_len, rootdir); 1109 DEBUGFS_ADD(retry_count, rootdir); 1110 DEBUGFS_ADD(excessive_retries, rootdir); 1111 1112 DEBUGFS_ADD(gpio_power, rootdir); 1113 DEBUGFS_ADD(start_recovery, rootdir); 1114 DEBUGFS_ADD(driver_state, rootdir); 1115 DEBUGFS_ADD(vifs_state, rootdir); 1116 DEBUGFS_ADD(dtim_interval, rootdir); 1117 DEBUGFS_ADD(suspend_dtim_interval, rootdir); 1118 DEBUGFS_ADD(beacon_interval, rootdir); 1119 DEBUGFS_ADD(beacon_filtering, rootdir); 1120 DEBUGFS_ADD(dynamic_ps_timeout, rootdir); 1121 DEBUGFS_ADD(forced_ps, rootdir); 1122 DEBUGFS_ADD(split_scan_timeout, rootdir); 1123 1124 streaming = debugfs_create_dir("rx_streaming", rootdir); 1125 if (!streaming || IS_ERR(streaming)) 1126 goto err; 1127 1128 DEBUGFS_ADD_PREFIX(rx_streaming, interval, streaming); 1129 DEBUGFS_ADD_PREFIX(rx_streaming, always, streaming); 1130 1131 1132 return 0; 1133 1134 err: 1135 if (IS_ERR(entry)) 1136 ret = PTR_ERR(entry); 1137 else 1138 ret = -ENOMEM; 1139 1140 return ret; 1141 } 1142 1143 void wl1271_debugfs_reset(struct wl1271 *wl) 1144 { 1145 if (!wl->stats.fw_stats) 1146 return; 1147 1148 memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats)); 1149 wl->stats.retry_count = 0; 1150 wl->stats.excessive_retries = 0; 1151 } 1152 1153 int wl1271_debugfs_init(struct wl1271 *wl) 1154 { 1155 int ret; 1156 struct dentry *rootdir; 1157 1158 rootdir = debugfs_create_dir(KBUILD_MODNAME, 1159 wl->hw->wiphy->debugfsdir); 1160 1161 if (IS_ERR(rootdir)) { 1162 ret = PTR_ERR(rootdir); 1163 goto err; 1164 } 1165 1166 wl->stats.fw_stats = kzalloc(sizeof(*wl->stats.fw_stats), 1167 GFP_KERNEL); 1168 1169 if (!wl->stats.fw_stats) { 1170 ret = -ENOMEM; 1171 goto err_fw; 1172 } 1173 1174 wl->stats.fw_stats_update = jiffies; 1175 1176 ret = wl1271_debugfs_add_files(wl, rootdir); 1177 1178 if (ret < 0) 1179 goto err_file; 1180 1181 return 0; 1182 1183 err_file: 1184 kfree(wl->stats.fw_stats); 1185 wl->stats.fw_stats = NULL; 1186 1187 err_fw: 1188 debugfs_remove_recursive(rootdir); 1189 1190 err: 1191 return ret; 1192 } 1193 1194 void wl1271_debugfs_exit(struct wl1271 *wl) 1195 { 1196 kfree(wl->stats.fw_stats); 1197 wl->stats.fw_stats = NULL; 1198 } 1199