drivers/net/wireless/ti/wlcore/debugfs.c

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