drivers/net/wireless/intel/iwlwifi/mvm/debugfs.c

   1 /******************************************************************************
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
   9  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of version 2 of the GNU General Public License as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  23  * USA
  24  *
  25  * The full GNU General Public License is included in this distribution
  26  * in the file called COPYING.
  27  *
  28  * Contact Information:
  29  *  Intel Linux Wireless <linuxwifi@intel.com>
  30  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  31  *
  32  * BSD LICENSE
  33  *
  34  * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
  35  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  *
  42  *  * Redistributions of source code must retain the above copyright
  43  *    notice, this list of conditions and the following disclaimer.
  44  *  * Redistributions in binary form must reproduce the above copyright
  45  *    notice, this list of conditions and the following disclaimer in
  46  *    the documentation and/or other materials provided with the
  47  *    distribution.
  48  *  * Neither the name Intel Corporation nor the names of its
  49  *    contributors may be used to endorse or promote products derived
  50  *    from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  53  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  54  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  55  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  56  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  57  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  58  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  59  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  60  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  61  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  62  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  63  *
  64  *****************************************************************************/
  65 #include <linux/vmalloc.h>
  66
  67 #include "mvm.h"
  68 #include "fw-dbg.h"
  69 #include "sta.h"
  70 #include "iwl-io.h"
  71 #include "debugfs.h"
  72 #include "iwl-fw-error-dump.h"
  73
  74 static ssize_t iwl_dbgfs_tx_flush_write(struct iwl_mvm *mvm, char *buf,
  75                                         size_t count, loff_t *ppos)
  76 {
  77         int ret;
  78         u32 scd_q_msk;
  79
  80         if (!mvm->ucode_loaded || mvm->cur_ucode != IWL_UCODE_REGULAR)
  81                 return -EIO;
  82
  83         if (sscanf(buf, "%x", &scd_q_msk) != 1)
  84                 return -EINVAL;
  85
  86         IWL_ERR(mvm, "FLUSHING queues: scd_q_msk = 0x%x\n", scd_q_msk);
  87
  88         mutex_lock(&mvm->mutex);
  89         ret =  iwl_mvm_flush_tx_path(mvm, scd_q_msk, 0) ? : count;
  90         mutex_unlock(&mvm->mutex);
  91
  92         return ret;
  93 }
  94
  95 static ssize_t iwl_dbgfs_sta_drain_write(struct iwl_mvm *mvm, char *buf,
  96                                          size_t count, loff_t *ppos)
  97 {
  98         struct iwl_mvm_sta *mvmsta;
  99         int sta_id, drain, ret;
 100
 101         if (!mvm->ucode_loaded || mvm->cur_ucode != IWL_UCODE_REGULAR)
 102                 return -EIO;
 103
 104         if (sscanf(buf, "%d %d", &sta_id, &drain) != 2)
 105                 return -EINVAL;
 106         if (sta_id < 0 || sta_id >= IWL_MVM_STATION_COUNT)
 107                 return -EINVAL;
 108         if (drain < 0 || drain > 1)
 109                 return -EINVAL;
 110
 111         mutex_lock(&mvm->mutex);
 112
 113         mvmsta = iwl_mvm_sta_from_staid_protected(mvm, sta_id);
 114
 115         if (!mvmsta)
 116                 ret = -ENOENT;
 117         else
 118                 ret = iwl_mvm_drain_sta(mvm, mvmsta, drain) ? : count;
 119
 120         mutex_unlock(&mvm->mutex);
 121
 122         return ret;
 123 }
 124
 125 static ssize_t iwl_dbgfs_sram_read(struct file *file, char __user *user_buf,
 126                                    size_t count, loff_t *ppos)
 127 {
 128         struct iwl_mvm *mvm = file->private_data;
 129         const struct fw_img *img;
 130         unsigned int ofs, len;
 131         size_t ret;
 132         u8 *ptr;
 133
 134         if (!mvm->ucode_loaded)
 135                 return -EINVAL;
 136
 137         /* default is to dump the entire data segment */
 138         img = &mvm->fw->img[mvm->cur_ucode];
 139         ofs = img->sec[IWL_UCODE_SECTION_DATA].offset;
 140         len = img->sec[IWL_UCODE_SECTION_DATA].len;
 141
 142         if (mvm->dbgfs_sram_len) {
 143                 ofs = mvm->dbgfs_sram_offset;
 144                 len = mvm->dbgfs_sram_len;
 145         }
 146
 147         ptr = kzalloc(len, GFP_KERNEL);
 148         if (!ptr)
 149                 return -ENOMEM;
 150
 151         iwl_trans_read_mem_bytes(mvm->trans, ofs, ptr, len);
 152
 153         ret = simple_read_from_buffer(user_buf, count, ppos, ptr, len);
 154
 155         kfree(ptr);
 156
 157         return ret;
 158 }
 159
 160 static ssize_t iwl_dbgfs_sram_write(struct iwl_mvm *mvm, char *buf,
 161                                     size_t count, loff_t *ppos)
 162 {
 163         const struct fw_img *img;
 164         u32 offset, len;
 165         u32 img_offset, img_len;
 166
 167         if (!mvm->ucode_loaded)
 168                 return -EINVAL;
 169
 170         img = &mvm->fw->img[mvm->cur_ucode];
 171         img_offset = img->sec[IWL_UCODE_SECTION_DATA].offset;
 172         img_len = img->sec[IWL_UCODE_SECTION_DATA].len;
 173
 174         if (sscanf(buf, "%x,%x", &offset, &len) == 2) {
 175                 if ((offset & 0x3) || (len & 0x3))
 176                         return -EINVAL;
 177
 178                 if (offset + len > img_offset + img_len)
 179                         return -EINVAL;
 180
 181                 mvm->dbgfs_sram_offset = offset;
 182                 mvm->dbgfs_sram_len = len;
 183         } else {
 184                 mvm->dbgfs_sram_offset = 0;
 185                 mvm->dbgfs_sram_len = 0;
 186         }
 187
 188         return count;
 189 }
 190
 191 static ssize_t iwl_dbgfs_set_nic_temperature_read(struct file *file,
 192                                                   char __user *user_buf,
 193                                                   size_t count, loff_t *ppos)
 194 {
 195         struct iwl_mvm *mvm = file->private_data;
 196         char buf[16];
 197         int pos;
 198
 199         if (!mvm->temperature_test)
 200                 pos = scnprintf(buf , sizeof(buf), "disabled\n");
 201         else
 202                 pos = scnprintf(buf , sizeof(buf), "%d\n", mvm->temperature);
 203
 204         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 205 }
 206
 207 /*
 208  * Set NIC Temperature
 209  * Cause the driver to ignore the actual NIC temperature reported by the FW
 210  * Enable: any value between IWL_MVM_DEBUG_SET_TEMPERATURE_MIN -
 211  * IWL_MVM_DEBUG_SET_TEMPERATURE_MAX
 212  * Disable: IWL_MVM_DEBUG_SET_TEMPERATURE_DISABLE
 213  */
 214 static ssize_t iwl_dbgfs_set_nic_temperature_write(struct iwl_mvm *mvm,
 215                                                    char *buf, size_t count,
 216                                                    loff_t *ppos)
 217 {
 218         int temperature;
 219
 220         if (!mvm->ucode_loaded && !mvm->temperature_test)
 221                 return -EIO;
 222
 223         if (kstrtoint(buf, 10, &temperature))
 224                 return -EINVAL;
 225         /* not a legal temperature */
 226         if ((temperature > IWL_MVM_DEBUG_SET_TEMPERATURE_MAX &&
 227              temperature != IWL_MVM_DEBUG_SET_TEMPERATURE_DISABLE) ||
 228             temperature < IWL_MVM_DEBUG_SET_TEMPERATURE_MIN)
 229                 return -EINVAL;
 230
 231         mutex_lock(&mvm->mutex);
 232         if (temperature == IWL_MVM_DEBUG_SET_TEMPERATURE_DISABLE) {
 233                 if (!mvm->temperature_test)
 234                         goto out;
 235
 236                 mvm->temperature_test = false;
 237                 /* Since we can't read the temp while awake, just set
 238                  * it to zero until we get the next RX stats from the
 239                  * firmware.
 240                  */
 241                 mvm->temperature = 0;
 242         } else {
 243                 mvm->temperature_test = true;
 244                 mvm->temperature = temperature;
 245         }
 246         IWL_DEBUG_TEMP(mvm, "%sabling debug set temperature (temp = %d)\n",
 247                        mvm->temperature_test ? "En" : "Dis" ,
 248                        mvm->temperature);
 249         /* handle the temperature change */
 250         iwl_mvm_tt_handler(mvm);
 251
 252 out:
 253         mutex_unlock(&mvm->mutex);
 254
 255         return count;
 256 }
 257
 258 static ssize_t iwl_dbgfs_nic_temp_read(struct file *file,
 259                                        char __user *user_buf,
 260                                        size_t count, loff_t *ppos)
 261 {
 262         struct iwl_mvm *mvm = file->private_data;
 263         char buf[16];
 264         int pos, temp;
 265
 266         if (!mvm->ucode_loaded)
 267                 return -EIO;
 268
 269         mutex_lock(&mvm->mutex);
 270         temp = iwl_mvm_get_temp(mvm);
 271         mutex_unlock(&mvm->mutex);
 272
 273         if (temp < 0)
 274                 return temp;
 275
 276         pos = scnprintf(buf , sizeof(buf), "%d\n", temp);
 277
 278         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 279 }
 280
 281 static ssize_t iwl_dbgfs_stations_read(struct file *file, char __user *user_buf,
 282                                        size_t count, loff_t *ppos)
 283 {
 284         struct iwl_mvm *mvm = file->private_data;
 285         struct ieee80211_sta *sta;
 286         char buf[400];
 287         int i, pos = 0, bufsz = sizeof(buf);
 288
 289         mutex_lock(&mvm->mutex);
 290
 291         for (i = 0; i < IWL_MVM_STATION_COUNT; i++) {
 292                 pos += scnprintf(buf + pos, bufsz - pos, "%.2d: ", i);
 293                 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
 294                                                 lockdep_is_held(&mvm->mutex));
 295                 if (!sta)
 296                         pos += scnprintf(buf + pos, bufsz - pos, "N/A\n");
 297                 else if (IS_ERR(sta))
 298                         pos += scnprintf(buf + pos, bufsz - pos, "%ld\n",
 299                                          PTR_ERR(sta));
 300                 else
 301                         pos += scnprintf(buf + pos, bufsz - pos, "%pM\n",
 302                                          sta->addr);
 303         }
 304
 305         mutex_unlock(&mvm->mutex);
 306
 307         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 308 }
 309
 310 static ssize_t iwl_dbgfs_disable_power_off_read(struct file *file,
 311                                                 char __user *user_buf,
 312                                                 size_t count, loff_t *ppos)
 313 {
 314         struct iwl_mvm *mvm = file->private_data;
 315         char buf[64];
 316         int bufsz = sizeof(buf);
 317         int pos = 0;
 318
 319         pos += scnprintf(buf+pos, bufsz-pos, "disable_power_off_d0=%d\n",
 320                          mvm->disable_power_off);
 321         pos += scnprintf(buf+pos, bufsz-pos, "disable_power_off_d3=%d\n",
 322                          mvm->disable_power_off_d3);
 323
 324         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 325 }
 326
 327 static ssize_t iwl_dbgfs_disable_power_off_write(struct iwl_mvm *mvm, char *buf,
 328                                                  size_t count, loff_t *ppos)
 329 {
 330         int ret, val;
 331
 332         if (!mvm->ucode_loaded)
 333                 return -EIO;
 334
 335         if (!strncmp("disable_power_off_d0=", buf, 21)) {
 336                 if (sscanf(buf + 21, "%d", &val) != 1)
 337                         return -EINVAL;
 338                 mvm->disable_power_off = val;
 339         } else if (!strncmp("disable_power_off_d3=", buf, 21)) {
 340                 if (sscanf(buf + 21, "%d", &val) != 1)
 341                         return -EINVAL;
 342                 mvm->disable_power_off_d3 = val;
 343         } else {
 344                 return -EINVAL;
 345         }
 346
 347         mutex_lock(&mvm->mutex);
 348         ret = iwl_mvm_power_update_device(mvm);
 349         mutex_unlock(&mvm->mutex);
 350
 351         return ret ?: count;
 352 }
 353
 354 #define BT_MBOX_MSG(_notif, _num, _field)                                    \
 355         ((le32_to_cpu((_notif)->mbox_msg[(_num)]) & BT_MBOX##_num##_##_field)\
 356         >> BT_MBOX##_num##_##_field##_POS)
 357
 358
 359 #define BT_MBOX_PRINT(_num, _field, _end)                                   \
 360                         pos += scnprintf(buf + pos, bufsz - pos,            \
 361                                          "\t%s: %d%s",                      \
 362                                          #_field,                           \
 363                                          BT_MBOX_MSG(notif, _num, _field),  \
 364                                          true ? "\n" : ", ");
 365
 366 static
 367 int iwl_mvm_coex_dump_mbox(struct iwl_bt_coex_profile_notif *notif, char *buf,
 368                            int pos, int bufsz)
 369 {
 370         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw0:\n");
 371
 372         BT_MBOX_PRINT(0, LE_SLAVE_LAT, false);
 373         BT_MBOX_PRINT(0, LE_PROF1, false);
 374         BT_MBOX_PRINT(0, LE_PROF2, false);
 375         BT_MBOX_PRINT(0, LE_PROF_OTHER, false);
 376         BT_MBOX_PRINT(0, CHL_SEQ_N, false);
 377         BT_MBOX_PRINT(0, INBAND_S, false);
 378         BT_MBOX_PRINT(0, LE_MIN_RSSI, false);
 379         BT_MBOX_PRINT(0, LE_SCAN, false);
 380         BT_MBOX_PRINT(0, LE_ADV, false);
 381         BT_MBOX_PRINT(0, LE_MAX_TX_POWER, false);
 382         BT_MBOX_PRINT(0, OPEN_CON_1, true);
 383
 384         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw1:\n");
 385
 386         BT_MBOX_PRINT(1, BR_MAX_TX_POWER, false);
 387         BT_MBOX_PRINT(1, IP_SR, false);
 388         BT_MBOX_PRINT(1, LE_MSTR, false);
 389         BT_MBOX_PRINT(1, AGGR_TRFC_LD, false);
 390         BT_MBOX_PRINT(1, MSG_TYPE, false);
 391         BT_MBOX_PRINT(1, SSN, true);
 392
 393         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw2:\n");
 394
 395         BT_MBOX_PRINT(2, SNIFF_ACT, false);
 396         BT_MBOX_PRINT(2, PAG, false);
 397         BT_MBOX_PRINT(2, INQUIRY, false);
 398         BT_MBOX_PRINT(2, CONN, false);
 399         BT_MBOX_PRINT(2, SNIFF_INTERVAL, false);
 400         BT_MBOX_PRINT(2, DISC, false);
 401         BT_MBOX_PRINT(2, SCO_TX_ACT, false);
 402         BT_MBOX_PRINT(2, SCO_RX_ACT, false);
 403         BT_MBOX_PRINT(2, ESCO_RE_TX, false);
 404         BT_MBOX_PRINT(2, SCO_DURATION, true);
 405
 406         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw3:\n");
 407
 408         BT_MBOX_PRINT(3, SCO_STATE, false);
 409         BT_MBOX_PRINT(3, SNIFF_STATE, false);
 410         BT_MBOX_PRINT(3, A2DP_STATE, false);
 411         BT_MBOX_PRINT(3, ACL_STATE, false);
 412         BT_MBOX_PRINT(3, MSTR_STATE, false);
 413         BT_MBOX_PRINT(3, OBX_STATE, false);
 414         BT_MBOX_PRINT(3, OPEN_CON_2, false);
 415         BT_MBOX_PRINT(3, TRAFFIC_LOAD, false);
 416         BT_MBOX_PRINT(3, CHL_SEQN_LSB, false);
 417         BT_MBOX_PRINT(3, INBAND_P, false);
 418         BT_MBOX_PRINT(3, MSG_TYPE_2, false);
 419         BT_MBOX_PRINT(3, SSN_2, false);
 420         BT_MBOX_PRINT(3, UPDATE_REQUEST, true);
 421
 422         return pos;
 423 }
 424
 425 static
 426 int iwl_mvm_coex_dump_mbox_old(struct iwl_bt_coex_profile_notif_old *notif,
 427                                char *buf, int pos, int bufsz)
 428 {
 429         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw0:\n");
 430
 431         BT_MBOX_PRINT(0, LE_SLAVE_LAT, false);
 432         BT_MBOX_PRINT(0, LE_PROF1, false);
 433         BT_MBOX_PRINT(0, LE_PROF2, false);
 434         BT_MBOX_PRINT(0, LE_PROF_OTHER, false);
 435         BT_MBOX_PRINT(0, CHL_SEQ_N, false);
 436         BT_MBOX_PRINT(0, INBAND_S, false);
 437         BT_MBOX_PRINT(0, LE_MIN_RSSI, false);
 438         BT_MBOX_PRINT(0, LE_SCAN, false);
 439         BT_MBOX_PRINT(0, LE_ADV, false);
 440         BT_MBOX_PRINT(0, LE_MAX_TX_POWER, false);
 441         BT_MBOX_PRINT(0, OPEN_CON_1, true);
 442
 443         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw1:\n");
 444
 445         BT_MBOX_PRINT(1, BR_MAX_TX_POWER, false);
 446         BT_MBOX_PRINT(1, IP_SR, false);
 447         BT_MBOX_PRINT(1, LE_MSTR, false);
 448         BT_MBOX_PRINT(1, AGGR_TRFC_LD, false);
 449         BT_MBOX_PRINT(1, MSG_TYPE, false);
 450         BT_MBOX_PRINT(1, SSN, true);
 451
 452         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw2:\n");
 453
 454         BT_MBOX_PRINT(2, SNIFF_ACT, false);
 455         BT_MBOX_PRINT(2, PAG, false);
 456         BT_MBOX_PRINT(2, INQUIRY, false);
 457         BT_MBOX_PRINT(2, CONN, false);
 458         BT_MBOX_PRINT(2, SNIFF_INTERVAL, false);
 459         BT_MBOX_PRINT(2, DISC, false);
 460         BT_MBOX_PRINT(2, SCO_TX_ACT, false);
 461         BT_MBOX_PRINT(2, SCO_RX_ACT, false);
 462         BT_MBOX_PRINT(2, ESCO_RE_TX, false);
 463         BT_MBOX_PRINT(2, SCO_DURATION, true);
 464
 465         pos += scnprintf(buf+pos, bufsz-pos, "MBOX dw3:\n");
 466
 467         BT_MBOX_PRINT(3, SCO_STATE, false);
 468         BT_MBOX_PRINT(3, SNIFF_STATE, false);
 469         BT_MBOX_PRINT(3, A2DP_STATE, false);
 470         BT_MBOX_PRINT(3, ACL_STATE, false);
 471         BT_MBOX_PRINT(3, MSTR_STATE, false);
 472         BT_MBOX_PRINT(3, OBX_STATE, false);
 473         BT_MBOX_PRINT(3, OPEN_CON_2, false);
 474         BT_MBOX_PRINT(3, TRAFFIC_LOAD, false);
 475         BT_MBOX_PRINT(3, CHL_SEQN_LSB, false);
 476         BT_MBOX_PRINT(3, INBAND_P, false);
 477         BT_MBOX_PRINT(3, MSG_TYPE_2, false);
 478         BT_MBOX_PRINT(3, SSN_2, false);
 479         BT_MBOX_PRINT(3, UPDATE_REQUEST, true);
 480
 481         return pos;
 482 }
 483
 484 static ssize_t iwl_dbgfs_bt_notif_read(struct file *file, char __user *user_buf,
 485                                        size_t count, loff_t *ppos)
 486 {
 487         struct iwl_mvm *mvm = file->private_data;
 488         char *buf;
 489         int ret, pos = 0, bufsz = sizeof(char) * 1024;
 490
 491         buf = kmalloc(bufsz, GFP_KERNEL);
 492         if (!buf)
 493                 return -ENOMEM;
 494
 495         mutex_lock(&mvm->mutex);
 496
 497         if (!fw_has_api(&mvm->fw->ucode_capa,
 498                         IWL_UCODE_TLV_API_BT_COEX_SPLIT)) {
 499                 struct iwl_bt_coex_profile_notif_old *notif =
 500                         &mvm->last_bt_notif_old;
 501
 502                 pos += iwl_mvm_coex_dump_mbox_old(notif, buf, pos, bufsz);
 503
 504                 pos += scnprintf(buf+pos, bufsz-pos, "bt_ci_compliance = %d\n",
 505                                  notif->bt_ci_compliance);
 506                 pos += scnprintf(buf+pos, bufsz-pos, "primary_ch_lut = %d\n",
 507                                  le32_to_cpu(notif->primary_ch_lut));
 508                 pos += scnprintf(buf+pos, bufsz-pos, "secondary_ch_lut = %d\n",
 509                                  le32_to_cpu(notif->secondary_ch_lut));
 510                 pos += scnprintf(buf+pos,
 511                                  bufsz-pos, "bt_activity_grading = %d\n",
 512                                  le32_to_cpu(notif->bt_activity_grading));
 513                 pos += scnprintf(buf+pos, bufsz-pos,
 514                                  "antenna isolation = %d CORUN LUT index = %d\n",
 515                                  mvm->last_ant_isol, mvm->last_corun_lut);
 516                 pos += scnprintf(buf + pos, bufsz - pos, "bt_rrc = %d\n",
 517                                  notif->rrc_enabled);
 518                 pos += scnprintf(buf + pos, bufsz - pos, "bt_ttc = %d\n",
 519                                  notif->ttc_enabled);
 520         } else {
 521                 struct iwl_bt_coex_profile_notif *notif =
 522                         &mvm->last_bt_notif;
 523
 524                 pos += iwl_mvm_coex_dump_mbox(notif, buf, pos, bufsz);
 525
 526                 pos += scnprintf(buf+pos, bufsz-pos, "bt_ci_compliance = %d\n",
 527                                  notif->bt_ci_compliance);
 528                 pos += scnprintf(buf+pos, bufsz-pos, "primary_ch_lut = %d\n",
 529                                  le32_to_cpu(notif->primary_ch_lut));
 530                 pos += scnprintf(buf+pos, bufsz-pos, "secondary_ch_lut = %d\n",
 531                                  le32_to_cpu(notif->secondary_ch_lut));
 532                 pos += scnprintf(buf+pos,
 533                                  bufsz-pos, "bt_activity_grading = %d\n",
 534                                  le32_to_cpu(notif->bt_activity_grading));
 535                 pos += scnprintf(buf+pos, bufsz-pos,
 536                                  "antenna isolation = %d CORUN LUT index = %d\n",
 537                                  mvm->last_ant_isol, mvm->last_corun_lut);
 538                 pos += scnprintf(buf + pos, bufsz - pos, "bt_rrc = %d\n",
 539                                  (notif->ttc_rrc_status >> 4) & 0xF);
 540                 pos += scnprintf(buf + pos, bufsz - pos, "bt_ttc = %d\n",
 541                                  notif->ttc_rrc_status & 0xF);
 542         }
 543
 544         pos += scnprintf(buf + pos, bufsz - pos, "sync_sco = %d\n",
 545                          IWL_MVM_BT_COEX_SYNC2SCO);
 546         pos += scnprintf(buf + pos, bufsz - pos, "mplut = %d\n",
 547                          IWL_MVM_BT_COEX_MPLUT);
 548         pos += scnprintf(buf + pos, bufsz - pos, "corunning = %d\n",
 549                          IWL_MVM_BT_COEX_CORUNNING);
 550
 551         mutex_unlock(&mvm->mutex);
 552
 553         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 554         kfree(buf);
 555
 556         return ret;
 557 }
 558 #undef BT_MBOX_PRINT
 559
 560 static ssize_t iwl_dbgfs_bt_cmd_read(struct file *file, char __user *user_buf,
 561                                      size_t count, loff_t *ppos)
 562 {
 563         struct iwl_mvm *mvm = file->private_data;
 564         char buf[256];
 565         int bufsz = sizeof(buf);
 566         int pos = 0;
 567
 568         mutex_lock(&mvm->mutex);
 569
 570         if (!fw_has_api(&mvm->fw->ucode_capa,
 571                         IWL_UCODE_TLV_API_BT_COEX_SPLIT)) {
 572                 struct iwl_bt_coex_ci_cmd_old *cmd = &mvm->last_bt_ci_cmd_old;
 573
 574                 pos += scnprintf(buf+pos, bufsz-pos,
 575                                  "Channel inhibition CMD\n");
 576                 pos += scnprintf(buf+pos, bufsz-pos,
 577                                "\tPrimary Channel Bitmap 0x%016llx\n",
 578                                le64_to_cpu(cmd->bt_primary_ci));
 579                 pos += scnprintf(buf+pos, bufsz-pos,
 580                                "\tSecondary Channel Bitmap 0x%016llx\n",
 581                                le64_to_cpu(cmd->bt_secondary_ci));
 582
 583                 pos += scnprintf(buf+pos, bufsz-pos,
 584                                  "BT Configuration CMD - 0=default, 1=never, 2=always\n");
 585                 pos += scnprintf(buf+pos, bufsz-pos, "\tACK Kill msk idx %d\n",
 586                                  mvm->bt_ack_kill_msk[0]);
 587                 pos += scnprintf(buf+pos, bufsz-pos, "\tCTS Kill msk idx %d\n",
 588                                  mvm->bt_cts_kill_msk[0]);
 589
 590         } else {
 591                 struct iwl_bt_coex_ci_cmd *cmd = &mvm->last_bt_ci_cmd;
 592
 593                 pos += scnprintf(buf+pos, bufsz-pos,
 594                                  "Channel inhibition CMD\n");
 595                 pos += scnprintf(buf+pos, bufsz-pos,
 596                                "\tPrimary Channel Bitmap 0x%016llx\n",
 597                                le64_to_cpu(cmd->bt_primary_ci));
 598                 pos += scnprintf(buf+pos, bufsz-pos,
 599                                "\tSecondary Channel Bitmap 0x%016llx\n",
 600                                le64_to_cpu(cmd->bt_secondary_ci));
 601         }
 602
 603         mutex_unlock(&mvm->mutex);
 604
 605         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 606 }
 607
 608 static ssize_t
 609 iwl_dbgfs_bt_tx_prio_write(struct iwl_mvm *mvm, char *buf,
 610                            size_t count, loff_t *ppos)
 611 {
 612         u32 bt_tx_prio;
 613
 614         if (sscanf(buf, "%u", &bt_tx_prio) != 1)
 615                 return -EINVAL;
 616         if (bt_tx_prio > 4)
 617                 return -EINVAL;
 618
 619         mvm->bt_tx_prio = bt_tx_prio;
 620
 621         return count;
 622 }
 623
 624 static ssize_t
 625 iwl_dbgfs_bt_force_ant_write(struct iwl_mvm *mvm, char *buf,
 626                              size_t count, loff_t *ppos)
 627 {
 628         static const char * const modes_str[BT_FORCE_ANT_MAX] = {
 629                 [BT_FORCE_ANT_DIS] = "dis",
 630                 [BT_FORCE_ANT_AUTO] = "auto",
 631                 [BT_FORCE_ANT_BT] = "bt",
 632                 [BT_FORCE_ANT_WIFI] = "wifi",
 633         };
 634         int ret, bt_force_ant_mode;
 635
 636         for (bt_force_ant_mode = 0;
 637              bt_force_ant_mode < ARRAY_SIZE(modes_str);
 638              bt_force_ant_mode++) {
 639                 if (!strcmp(buf, modes_str[bt_force_ant_mode]))
 640                         break;
 641         }
 642
 643         if (bt_force_ant_mode >= ARRAY_SIZE(modes_str))
 644                 return -EINVAL;
 645
 646         ret = 0;
 647         mutex_lock(&mvm->mutex);
 648         if (mvm->bt_force_ant_mode == bt_force_ant_mode)
 649                 goto out;
 650
 651         mvm->bt_force_ant_mode = bt_force_ant_mode;
 652         IWL_DEBUG_COEX(mvm, "Force mode: %s\n",
 653                        modes_str[mvm->bt_force_ant_mode]);
 654         ret = iwl_send_bt_init_conf(mvm);
 655
 656 out:
 657         mutex_unlock(&mvm->mutex);
 658         return ret ?: count;
 659 }
 660
 661 #define PRINT_STATS_LE32(_struct, _memb)                                \
 662                          pos += scnprintf(buf + pos, bufsz - pos,       \
 663                                           fmt_table, #_memb,            \
 664                                           le32_to_cpu(_struct->_memb))
 665
 666 static ssize_t iwl_dbgfs_fw_rx_stats_read(struct file *file,
 667                                           char __user *user_buf, size_t count,
 668                                           loff_t *ppos)
 669 {
 670         struct iwl_mvm *mvm = file->private_data;
 671         static const char *fmt_table = "\t%-30s %10u\n";
 672         static const char *fmt_header = "%-32s\n";
 673         int pos = 0;
 674         char *buf;
 675         int ret;
 676         /* 43 is the size of each data line, 33 is the size of each header */
 677         size_t bufsz =
 678                 ((sizeof(struct mvm_statistics_rx) / sizeof(__le32)) * 43) +
 679                 (4 * 33) + 1;
 680
 681         struct mvm_statistics_rx_phy *ofdm;
 682         struct mvm_statistics_rx_phy *cck;
 683         struct mvm_statistics_rx_non_phy *general;
 684         struct mvm_statistics_rx_ht_phy *ht;
 685
 686         buf = kzalloc(bufsz, GFP_KERNEL);
 687         if (!buf)
 688                 return -ENOMEM;
 689
 690         mutex_lock(&mvm->mutex);
 691
 692         ofdm = &mvm->rx_stats.ofdm;
 693         cck = &mvm->rx_stats.cck;
 694         general = &mvm->rx_stats.general;
 695         ht = &mvm->rx_stats.ofdm_ht;
 696
 697         pos += scnprintf(buf + pos, bufsz - pos, fmt_header,
 698                          "Statistics_Rx - OFDM");
 699         PRINT_STATS_LE32(ofdm, ina_cnt);
 700         PRINT_STATS_LE32(ofdm, fina_cnt);
 701         PRINT_STATS_LE32(ofdm, plcp_err);
 702         PRINT_STATS_LE32(ofdm, crc32_err);
 703         PRINT_STATS_LE32(ofdm, overrun_err);
 704         PRINT_STATS_LE32(ofdm, early_overrun_err);
 705         PRINT_STATS_LE32(ofdm, crc32_good);
 706         PRINT_STATS_LE32(ofdm, false_alarm_cnt);
 707         PRINT_STATS_LE32(ofdm, fina_sync_err_cnt);
 708         PRINT_STATS_LE32(ofdm, sfd_timeout);
 709         PRINT_STATS_LE32(ofdm, fina_timeout);
 710         PRINT_STATS_LE32(ofdm, unresponded_rts);
 711         PRINT_STATS_LE32(ofdm, rxe_frame_lmt_overrun);
 712         PRINT_STATS_LE32(ofdm, sent_ack_cnt);
 713         PRINT_STATS_LE32(ofdm, sent_cts_cnt);
 714         PRINT_STATS_LE32(ofdm, sent_ba_rsp_cnt);
 715         PRINT_STATS_LE32(ofdm, dsp_self_kill);
 716         PRINT_STATS_LE32(ofdm, mh_format_err);
 717         PRINT_STATS_LE32(ofdm, re_acq_main_rssi_sum);
 718         PRINT_STATS_LE32(ofdm, reserved);
 719
 720         pos += scnprintf(buf + pos, bufsz - pos, fmt_header,
 721                          "Statistics_Rx - CCK");
 722         PRINT_STATS_LE32(cck, ina_cnt);
 723         PRINT_STATS_LE32(cck, fina_cnt);
 724         PRINT_STATS_LE32(cck, plcp_err);
 725         PRINT_STATS_LE32(cck, crc32_err);
 726         PRINT_STATS_LE32(cck, overrun_err);
 727         PRINT_STATS_LE32(cck, early_overrun_err);
 728         PRINT_STATS_LE32(cck, crc32_good);
 729         PRINT_STATS_LE32(cck, false_alarm_cnt);
 730         PRINT_STATS_LE32(cck, fina_sync_err_cnt);
 731         PRINT_STATS_LE32(cck, sfd_timeout);
 732         PRINT_STATS_LE32(cck, fina_timeout);
 733         PRINT_STATS_LE32(cck, unresponded_rts);
 734         PRINT_STATS_LE32(cck, rxe_frame_lmt_overrun);
 735         PRINT_STATS_LE32(cck, sent_ack_cnt);
 736         PRINT_STATS_LE32(cck, sent_cts_cnt);
 737         PRINT_STATS_LE32(cck, sent_ba_rsp_cnt);
 738         PRINT_STATS_LE32(cck, dsp_self_kill);
 739         PRINT_STATS_LE32(cck, mh_format_err);
 740         PRINT_STATS_LE32(cck, re_acq_main_rssi_sum);
 741         PRINT_STATS_LE32(cck, reserved);
 742
 743         pos += scnprintf(buf + pos, bufsz - pos, fmt_header,
 744                          "Statistics_Rx - GENERAL");
 745         PRINT_STATS_LE32(general, bogus_cts);
 746         PRINT_STATS_LE32(general, bogus_ack);
 747         PRINT_STATS_LE32(general, non_bssid_frames);
 748         PRINT_STATS_LE32(general, filtered_frames);
 749         PRINT_STATS_LE32(general, non_channel_beacons);
 750         PRINT_STATS_LE32(general, channel_beacons);
 751         PRINT_STATS_LE32(general, num_missed_bcon);
 752         PRINT_STATS_LE32(general, adc_rx_saturation_time);
 753         PRINT_STATS_LE32(general, ina_detection_search_time);
 754         PRINT_STATS_LE32(general, beacon_silence_rssi_a);
 755         PRINT_STATS_LE32(general, beacon_silence_rssi_b);
 756         PRINT_STATS_LE32(general, beacon_silence_rssi_c);
 757         PRINT_STATS_LE32(general, interference_data_flag);
 758         PRINT_STATS_LE32(general, channel_load);
 759         PRINT_STATS_LE32(general, dsp_false_alarms);
 760         PRINT_STATS_LE32(general, beacon_rssi_a);
 761         PRINT_STATS_LE32(general, beacon_rssi_b);
 762         PRINT_STATS_LE32(general, beacon_rssi_c);
 763         PRINT_STATS_LE32(general, beacon_energy_a);
 764         PRINT_STATS_LE32(general, beacon_energy_b);
 765         PRINT_STATS_LE32(general, beacon_energy_c);
 766         PRINT_STATS_LE32(general, num_bt_kills);
 767         PRINT_STATS_LE32(general, mac_id);
 768         PRINT_STATS_LE32(general, directed_data_mpdu);
 769
 770         pos += scnprintf(buf + pos, bufsz - pos, fmt_header,
 771                          "Statistics_Rx - HT");
 772         PRINT_STATS_LE32(ht, plcp_err);
 773         PRINT_STATS_LE32(ht, overrun_err);
 774         PRINT_STATS_LE32(ht, early_overrun_err);
 775         PRINT_STATS_LE32(ht, crc32_good);
 776         PRINT_STATS_LE32(ht, crc32_err);
 777         PRINT_STATS_LE32(ht, mh_format_err);
 778         PRINT_STATS_LE32(ht, agg_crc32_good);
 779         PRINT_STATS_LE32(ht, agg_mpdu_cnt);
 780         PRINT_STATS_LE32(ht, agg_cnt);
 781         PRINT_STATS_LE32(ht, unsupport_mcs);
 782
 783         mutex_unlock(&mvm->mutex);
 784
 785         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 786         kfree(buf);
 787
 788         return ret;
 789 }
 790 #undef PRINT_STAT_LE32
 791
 792 static ssize_t iwl_dbgfs_frame_stats_read(struct iwl_mvm *mvm,
 793                                           char __user *user_buf, size_t count,
 794                                           loff_t *ppos,
 795                                           struct iwl_mvm_frame_stats *stats)
 796 {
 797         char *buff, *pos, *endpos;
 798         int idx, i;
 799         int ret;
 800         static const size_t bufsz = 1024;
 801
 802         buff = kmalloc(bufsz, GFP_KERNEL);
 803         if (!buff)
 804                 return -ENOMEM;
 805
 806         spin_lock_bh(&mvm->drv_stats_lock);
 807
 808         pos = buff;
 809         endpos = pos + bufsz;
 810
 811         pos += scnprintf(pos, endpos - pos,
 812                          "Legacy/HT/VHT\t:\t%d/%d/%d\n",
 813                          stats->legacy_frames,
 814                          stats->ht_frames,
 815                          stats->vht_frames);
 816         pos += scnprintf(pos, endpos - pos, "20/40/80\t:\t%d/%d/%d\n",
 817                          stats->bw_20_frames,
 818                          stats->bw_40_frames,
 819                          stats->bw_80_frames);
 820         pos += scnprintf(pos, endpos - pos, "NGI/SGI\t\t:\t%d/%d\n",
 821                          stats->ngi_frames,
 822                          stats->sgi_frames);
 823         pos += scnprintf(pos, endpos - pos, "SISO/MIMO2\t:\t%d/%d\n",
 824                          stats->siso_frames,
 825                          stats->mimo2_frames);
 826         pos += scnprintf(pos, endpos - pos, "FAIL/SCSS\t:\t%d/%d\n",
 827                          stats->fail_frames,
 828                          stats->success_frames);
 829         pos += scnprintf(pos, endpos - pos, "MPDUs agg\t:\t%d\n",
 830                          stats->agg_frames);
 831         pos += scnprintf(pos, endpos - pos, "A-MPDUs\t\t:\t%d\n",
 832                          stats->ampdu_count);
 833         pos += scnprintf(pos, endpos - pos, "Avg MPDUs/A-MPDU:\t%d\n",
 834                          stats->ampdu_count > 0 ?
 835                          (stats->agg_frames / stats->ampdu_count) : 0);
 836
 837         pos += scnprintf(pos, endpos - pos, "Last Rates\n");
 838
 839         idx = stats->last_frame_idx - 1;
 840         for (i = 0; i < ARRAY_SIZE(stats->last_rates); i++) {
 841                 idx = (idx + 1) % ARRAY_SIZE(stats->last_rates);
 842                 if (stats->last_rates[idx] == 0)
 843                         continue;
 844                 pos += scnprintf(pos, endpos - pos, "Rate[%d]: ",
 845                                  (int)(ARRAY_SIZE(stats->last_rates) - i));
 846                 pos += rs_pretty_print_rate(pos, stats->last_rates[idx]);
 847         }
 848         spin_unlock_bh(&mvm->drv_stats_lock);
 849
 850         ret = simple_read_from_buffer(user_buf, count, ppos, buff, pos - buff);
 851         kfree(buff);
 852
 853         return ret;
 854 }
 855
 856 static ssize_t iwl_dbgfs_drv_rx_stats_read(struct file *file,
 857                                            char __user *user_buf, size_t count,
 858                                            loff_t *ppos)
 859 {
 860         struct iwl_mvm *mvm = file->private_data;
 861
 862         return iwl_dbgfs_frame_stats_read(mvm, user_buf, count, ppos,
 863                                           &mvm->drv_rx_stats);
 864 }
 865
 866 static ssize_t iwl_dbgfs_fw_restart_write(struct iwl_mvm *mvm, char *buf,
 867                                           size_t count, loff_t *ppos)
 868 {
 869         int ret;
 870
 871         mutex_lock(&mvm->mutex);
 872
 873         /* allow one more restart that we're provoking here */
 874         if (mvm->restart_fw >= 0)
 875                 mvm->restart_fw++;
 876
 877         /* take the return value to make compiler happy - it will fail anyway */
 878         ret = iwl_mvm_send_cmd_pdu(mvm, REPLY_ERROR, 0, 0, NULL);
 879
 880         mutex_unlock(&mvm->mutex);
 881
 882         return count;
 883 }
 884
 885 static ssize_t iwl_dbgfs_fw_nmi_write(struct iwl_mvm *mvm, char *buf,
 886                                       size_t count, loff_t *ppos)
 887 {
 888         int ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_NMI);
 889         if (ret)
 890                 return ret;
 891
 892         iwl_force_nmi(mvm->trans);
 893
 894         iwl_mvm_unref(mvm, IWL_MVM_REF_NMI);
 895
 896         return count;
 897 }
 898
 899 static ssize_t
 900 iwl_dbgfs_scan_ant_rxchain_read(struct file *file,
 901                                 char __user *user_buf,
 902                                 size_t count, loff_t *ppos)
 903 {
 904         struct iwl_mvm *mvm = file->private_data;
 905         int pos = 0;
 906         char buf[32];
 907         const size_t bufsz = sizeof(buf);
 908
 909         /* print which antennas were set for the scan command by the user */
 910         pos += scnprintf(buf + pos, bufsz - pos, "Antennas for scan: ");
 911         if (mvm->scan_rx_ant & ANT_A)
 912                 pos += scnprintf(buf + pos, bufsz - pos, "A");
 913         if (mvm->scan_rx_ant & ANT_B)
 914                 pos += scnprintf(buf + pos, bufsz - pos, "B");
 915         if (mvm->scan_rx_ant & ANT_C)
 916                 pos += scnprintf(buf + pos, bufsz - pos, "C");
 917         pos += scnprintf(buf + pos, bufsz - pos, " (%hhx)\n", mvm->scan_rx_ant);
 918
 919         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 920 }
 921
 922 static ssize_t
 923 iwl_dbgfs_scan_ant_rxchain_write(struct iwl_mvm *mvm, char *buf,
 924                                  size_t count, loff_t *ppos)
 925 {
 926         u8 scan_rx_ant;
 927
 928         if (sscanf(buf, "%hhx", &scan_rx_ant) != 1)
 929                 return -EINVAL;
 930         if (scan_rx_ant > ANT_ABC)
 931                 return -EINVAL;
 932         if (scan_rx_ant & ~(iwl_mvm_get_valid_rx_ant(mvm)))
 933                 return -EINVAL;
 934
 935         if (mvm->scan_rx_ant != scan_rx_ant) {
 936                 mvm->scan_rx_ant = scan_rx_ant;
 937                 if (fw_has_capa(&mvm->fw->ucode_capa,
 938                                 IWL_UCODE_TLV_CAPA_UMAC_SCAN))
 939                         iwl_mvm_config_scan(mvm);
 940         }
 941
 942         return count;
 943 }
 944
 945 static ssize_t iwl_dbgfs_fw_dbg_conf_read(struct file *file,
 946                                           char __user *user_buf,
 947                                           size_t count, loff_t *ppos)
 948 {
 949         struct iwl_mvm *mvm = file->private_data;
 950         int conf;
 951         char buf[8];
 952         const size_t bufsz = sizeof(buf);
 953         int pos = 0;
 954
 955         mutex_lock(&mvm->mutex);
 956         conf = mvm->fw_dbg_conf;
 957         mutex_unlock(&mvm->mutex);
 958
 959         pos += scnprintf(buf + pos, bufsz - pos, "%d\n", conf);
 960
 961         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
 962 }
 963
 964 /*
 965  * Enable / Disable continuous recording.
 966  * Cause the FW to start continuous recording, by sending the relevant hcmd.
 967  * Enable: input of every integer larger than 0, ENABLE_CONT_RECORDING.
 968  * Disable: for 0 as input, DISABLE_CONT_RECORDING.
 969  */
 970 static ssize_t iwl_dbgfs_cont_recording_write(struct iwl_mvm *mvm,
 971                                               char *buf, size_t count,
 972                                               loff_t *ppos)
 973 {
 974         struct iwl_trans *trans = mvm->trans;
 975         const struct iwl_fw_dbg_dest_tlv *dest = trans->dbg_dest_tlv;
 976         struct iwl_continuous_record_cmd cont_rec = {};
 977         int ret, rec_mode;
 978
 979         if (!dest)
 980                 return -EOPNOTSUPP;
 981
 982         if (dest->monitor_mode != SMEM_MODE ||
 983             trans->cfg->device_family != IWL_DEVICE_FAMILY_8000)
 984                 return -EOPNOTSUPP;
 985
 986         ret = kstrtouint(buf, 0, &rec_mode);
 987         if (ret)
 988                 return ret;
 989
 990         cont_rec.record_mode.enable_recording = rec_mode ?
 991                 cpu_to_le16(ENABLE_CONT_RECORDING) :
 992                 cpu_to_le16(DISABLE_CONT_RECORDING);
 993
 994         mutex_lock(&mvm->mutex);
 995         ret = iwl_mvm_send_cmd_pdu(mvm, LDBG_CONFIG_CMD, 0,
 996                                    sizeof(cont_rec), &cont_rec);
 997         mutex_unlock(&mvm->mutex);
 998
 999         return ret ?: count;
1000 }
1001
1002 static ssize_t iwl_dbgfs_fw_dbg_conf_write(struct iwl_mvm *mvm,
1003                                            char *buf, size_t count,
1004                                            loff_t *ppos)
1005 {
1006         unsigned int conf_id;
1007         int ret;
1008
1009         ret = kstrtouint(buf, 0, &conf_id);
1010         if (ret)
1011                 return ret;
1012
1013         if (WARN_ON(conf_id >= FW_DBG_CONF_MAX))
1014                 return -EINVAL;
1015
1016         mutex_lock(&mvm->mutex);
1017         ret = iwl_mvm_start_fw_dbg_conf(mvm, conf_id);
1018         mutex_unlock(&mvm->mutex);
1019
1020         return ret ?: count;
1021 }
1022
1023 static ssize_t iwl_dbgfs_fw_dbg_collect_write(struct iwl_mvm *mvm,
1024                                               char *buf, size_t count,
1025                                               loff_t *ppos)
1026 {
1027         int ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PRPH_WRITE);
1028
1029         if (ret)
1030                 return ret;
1031
1032         iwl_mvm_fw_dbg_collect(mvm, FW_DBG_TRIGGER_USER, buf,
1033                                (count - 1), NULL);
1034
1035         iwl_mvm_unref(mvm, IWL_MVM_REF_PRPH_WRITE);
1036
1037         return count;
1038 }
1039
1040 #define ADD_TEXT(...) pos += scnprintf(buf + pos, bufsz - pos, __VA_ARGS__)
1041 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
1042 static ssize_t iwl_dbgfs_bcast_filters_read(struct file *file,
1043                                             char __user *user_buf,
1044                                             size_t count, loff_t *ppos)
1045 {
1046         struct iwl_mvm *mvm = file->private_data;
1047         struct iwl_bcast_filter_cmd cmd;
1048         const struct iwl_fw_bcast_filter *filter;
1049         char *buf;
1050         int bufsz = 1024;
1051         int i, j, pos = 0;
1052         ssize_t ret;
1053
1054         buf = kzalloc(bufsz, GFP_KERNEL);
1055         if (!buf)
1056                 return -ENOMEM;
1057
1058         mutex_lock(&mvm->mutex);
1059         if (!iwl_mvm_bcast_filter_build_cmd(mvm, &cmd)) {
1060                 ADD_TEXT("None\n");
1061                 mutex_unlock(&mvm->mutex);
1062                 goto out;
1063         }
1064         mutex_unlock(&mvm->mutex);
1065
1066         for (i = 0; cmd.filters[i].attrs[0].mask; i++) {
1067                 filter = &cmd.filters[i];
1068
1069                 ADD_TEXT("Filter [%d]:\n", i);
1070                 ADD_TEXT("\tDiscard=%d\n", filter->discard);
1071                 ADD_TEXT("\tFrame Type: %s\n",
1072                          filter->frame_type ? "IPv4" : "Generic");
1073
1074                 for (j = 0; j < ARRAY_SIZE(filter->attrs); j++) {
1075                         const struct iwl_fw_bcast_filter_attr *attr;
1076
1077                         attr = &filter->attrs[j];
1078                         if (!attr->mask)
1079                                 break;
1080
1081                         ADD_TEXT("\tAttr [%d]: offset=%d (from %s), mask=0x%x, value=0x%x reserved=0x%x\n",
1082                                  j, attr->offset,
1083                                  attr->offset_type ? "IP End" :
1084                                                      "Payload Start",
1085                                  be32_to_cpu(attr->mask),
1086                                  be32_to_cpu(attr->val),
1087                                  le16_to_cpu(attr->reserved1));
1088                 }
1089         }
1090 out:
1091         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1092         kfree(buf);
1093         return ret;
1094 }
1095
1096 static ssize_t iwl_dbgfs_bcast_filters_write(struct iwl_mvm *mvm, char *buf,
1097                                              size_t count, loff_t *ppos)
1098 {
1099         int pos, next_pos;
1100         struct iwl_fw_bcast_filter filter = {};
1101         struct iwl_bcast_filter_cmd cmd;
1102         u32 filter_id, attr_id, mask, value;
1103         int err = 0;
1104
1105         if (sscanf(buf, "%d %hhi %hhi %n", &filter_id, &filter.discard,
1106                    &filter.frame_type, &pos) != 3)
1107                 return -EINVAL;
1108
1109         if (filter_id >= ARRAY_SIZE(mvm->dbgfs_bcast_filtering.cmd.filters) ||
1110             filter.frame_type > BCAST_FILTER_FRAME_TYPE_IPV4)
1111                 return -EINVAL;
1112
1113         for (attr_id = 0; attr_id < ARRAY_SIZE(filter.attrs);
1114              attr_id++) {
1115                 struct iwl_fw_bcast_filter_attr *attr =
1116                                 &filter.attrs[attr_id];
1117
1118                 if (pos >= count)
1119                         break;
1120
1121                 if (sscanf(&buf[pos], "%hhi %hhi %i %i %n",
1122                            &attr->offset, &attr->offset_type,
1123                            &mask, &value, &next_pos) != 4)
1124                         return -EINVAL;
1125
1126                 attr->mask = cpu_to_be32(mask);
1127                 attr->val = cpu_to_be32(value);
1128                 if (mask)
1129                         filter.num_attrs++;
1130
1131                 pos += next_pos;
1132         }
1133
1134         mutex_lock(&mvm->mutex);
1135         memcpy(&mvm->dbgfs_bcast_filtering.cmd.filters[filter_id],
1136                &filter, sizeof(filter));
1137
1138         /* send updated bcast filtering configuration */
1139         if (mvm->dbgfs_bcast_filtering.override &&
1140             iwl_mvm_bcast_filter_build_cmd(mvm, &cmd))
1141                 err = iwl_mvm_send_cmd_pdu(mvm, BCAST_FILTER_CMD, 0,
1142                                            sizeof(cmd), &cmd);
1143         mutex_unlock(&mvm->mutex);
1144
1145         return err ?: count;
1146 }
1147
1148 static ssize_t iwl_dbgfs_bcast_filters_macs_read(struct file *file,
1149                                                  char __user *user_buf,
1150                                                  size_t count, loff_t *ppos)
1151 {
1152         struct iwl_mvm *mvm = file->private_data;
1153         struct iwl_bcast_filter_cmd cmd;
1154         char *buf;
1155         int bufsz = 1024;
1156         int i, pos = 0;
1157         ssize_t ret;
1158
1159         buf = kzalloc(bufsz, GFP_KERNEL);
1160         if (!buf)
1161                 return -ENOMEM;
1162
1163         mutex_lock(&mvm->mutex);
1164         if (!iwl_mvm_bcast_filter_build_cmd(mvm, &cmd)) {
1165                 ADD_TEXT("None\n");
1166                 mutex_unlock(&mvm->mutex);
1167                 goto out;
1168         }
1169         mutex_unlock(&mvm->mutex);
1170
1171         for (i = 0; i < ARRAY_SIZE(cmd.macs); i++) {
1172                 const struct iwl_fw_bcast_mac *mac = &cmd.macs[i];
1173
1174                 ADD_TEXT("Mac [%d]: discard=%d attached_filters=0x%x\n",
1175                          i, mac->default_discard, mac->attached_filters);
1176         }
1177 out:
1178         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1179         kfree(buf);
1180         return ret;
1181 }
1182
1183 static ssize_t iwl_dbgfs_bcast_filters_macs_write(struct iwl_mvm *mvm,
1184                                                   char *buf, size_t count,
1185                                                   loff_t *ppos)
1186 {
1187         struct iwl_bcast_filter_cmd cmd;
1188         struct iwl_fw_bcast_mac mac = {};
1189         u32 mac_id, attached_filters;
1190         int err = 0;
1191
1192         if (!mvm->bcast_filters)
1193                 return -ENOENT;
1194
1195         if (sscanf(buf, "%d %hhi %i", &mac_id, &mac.default_discard,
1196                    &attached_filters) != 3)
1197                 return -EINVAL;
1198
1199         if (mac_id >= ARRAY_SIZE(cmd.macs) ||
1200             mac.default_discard > 1 ||
1201             attached_filters >= BIT(ARRAY_SIZE(cmd.filters)))
1202                 return -EINVAL;
1203
1204         mac.attached_filters = cpu_to_le16(attached_filters);
1205
1206         mutex_lock(&mvm->mutex);
1207         memcpy(&mvm->dbgfs_bcast_filtering.cmd.macs[mac_id],
1208                &mac, sizeof(mac));
1209
1210         /* send updated bcast filtering configuration */
1211         if (mvm->dbgfs_bcast_filtering.override &&
1212             iwl_mvm_bcast_filter_build_cmd(mvm, &cmd))
1213                 err = iwl_mvm_send_cmd_pdu(mvm, BCAST_FILTER_CMD, 0,
1214                                            sizeof(cmd), &cmd);
1215         mutex_unlock(&mvm->mutex);
1216
1217         return err ?: count;
1218 }
1219 #endif
1220
1221 #ifdef CONFIG_PM_SLEEP
1222 static ssize_t iwl_dbgfs_d3_sram_write(struct iwl_mvm *mvm, char *buf,
1223                                        size_t count, loff_t *ppos)
1224 {
1225         int store;
1226
1227         if (sscanf(buf, "%d", &store) != 1)
1228                 return -EINVAL;
1229
1230         mvm->store_d3_resume_sram = store;
1231
1232         return count;
1233 }
1234
1235 static ssize_t iwl_dbgfs_d3_sram_read(struct file *file, char __user *user_buf,
1236                                       size_t count, loff_t *ppos)
1237 {
1238         struct iwl_mvm *mvm = file->private_data;
1239         const struct fw_img *img;
1240         int ofs, len, pos = 0;
1241         size_t bufsz, ret;
1242         char *buf;
1243         u8 *ptr = mvm->d3_resume_sram;
1244
1245         img = &mvm->fw->img[IWL_UCODE_WOWLAN];
1246         len = img->sec[IWL_UCODE_SECTION_DATA].len;
1247
1248         bufsz = len * 4 + 256;
1249         buf = kzalloc(bufsz, GFP_KERNEL);
1250         if (!buf)
1251                 return -ENOMEM;
1252
1253         pos += scnprintf(buf, bufsz, "D3 SRAM capture: %sabled\n",
1254                          mvm->store_d3_resume_sram ? "en" : "dis");
1255
1256         if (ptr) {
1257                 for (ofs = 0; ofs < len; ofs += 16) {
1258                         pos += scnprintf(buf + pos, bufsz - pos,
1259                                          "0x%.4x %16ph\n", ofs, ptr + ofs);
1260                 }
1261         } else {
1262                 pos += scnprintf(buf + pos, bufsz - pos,
1263                                  "(no data captured)\n");
1264         }
1265
1266         ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1267
1268         kfree(buf);
1269
1270         return ret;
1271 }
1272 #endif
1273
1274 #define PRINT_MVM_REF(ref) do {                                         \
1275         if (mvm->refs[ref])                                             \
1276                 pos += scnprintf(buf + pos, bufsz - pos,                \
1277                                  "\t(0x%lx): %d %s\n",                  \
1278                                  BIT(ref), mvm->refs[ref], #ref);       \
1279 } while (0)
1280
1281 static ssize_t iwl_dbgfs_d0i3_refs_read(struct file *file,
1282                                         char __user *user_buf,
1283                                         size_t count, loff_t *ppos)
1284 {
1285         struct iwl_mvm *mvm = file->private_data;
1286         int i, pos = 0;
1287         char buf[256];
1288         const size_t bufsz = sizeof(buf);
1289         u32 refs = 0;
1290
1291         for (i = 0; i < IWL_MVM_REF_COUNT; i++)
1292                 if (mvm->refs[i])
1293                         refs |= BIT(i);
1294
1295         pos += scnprintf(buf + pos, bufsz - pos, "taken mvm refs: 0x%x\n",
1296                          refs);
1297
1298         PRINT_MVM_REF(IWL_MVM_REF_UCODE_DOWN);
1299         PRINT_MVM_REF(IWL_MVM_REF_SCAN);
1300         PRINT_MVM_REF(IWL_MVM_REF_ROC);
1301         PRINT_MVM_REF(IWL_MVM_REF_ROC_AUX);
1302         PRINT_MVM_REF(IWL_MVM_REF_P2P_CLIENT);
1303         PRINT_MVM_REF(IWL_MVM_REF_AP_IBSS);
1304         PRINT_MVM_REF(IWL_MVM_REF_USER);
1305         PRINT_MVM_REF(IWL_MVM_REF_TX);
1306         PRINT_MVM_REF(IWL_MVM_REF_TX_AGG);
1307         PRINT_MVM_REF(IWL_MVM_REF_ADD_IF);
1308         PRINT_MVM_REF(IWL_MVM_REF_START_AP);
1309         PRINT_MVM_REF(IWL_MVM_REF_BSS_CHANGED);
1310         PRINT_MVM_REF(IWL_MVM_REF_PREPARE_TX);
1311         PRINT_MVM_REF(IWL_MVM_REF_PROTECT_TDLS);
1312         PRINT_MVM_REF(IWL_MVM_REF_CHECK_CTKILL);
1313         PRINT_MVM_REF(IWL_MVM_REF_PRPH_READ);
1314         PRINT_MVM_REF(IWL_MVM_REF_PRPH_WRITE);
1315         PRINT_MVM_REF(IWL_MVM_REF_NMI);
1316         PRINT_MVM_REF(IWL_MVM_REF_TM_CMD);
1317         PRINT_MVM_REF(IWL_MVM_REF_EXIT_WORK);
1318         PRINT_MVM_REF(IWL_MVM_REF_PROTECT_CSA);
1319         PRINT_MVM_REF(IWL_MVM_REF_FW_DBG_COLLECT);
1320         PRINT_MVM_REF(IWL_MVM_REF_INIT_UCODE);
1321
1322         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1323 }
1324
1325 static ssize_t iwl_dbgfs_d0i3_refs_write(struct iwl_mvm *mvm, char *buf,
1326                                          size_t count, loff_t *ppos)
1327 {
1328         unsigned long value;
1329         int ret;
1330         bool taken;
1331
1332         ret = kstrtoul(buf, 10, &value);
1333         if (ret < 0)
1334                 return ret;
1335
1336         mutex_lock(&mvm->mutex);
1337
1338         taken = mvm->refs[IWL_MVM_REF_USER];
1339         if (value == 1 && !taken)
1340                 iwl_mvm_ref(mvm, IWL_MVM_REF_USER);
1341         else if (value == 0 && taken)
1342                 iwl_mvm_unref(mvm, IWL_MVM_REF_USER);
1343         else
1344                 ret = -EINVAL;
1345
1346         mutex_unlock(&mvm->mutex);
1347
1348         if (ret < 0)
1349                 return ret;
1350         return count;
1351 }
1352
1353 #define MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz) \
1354         _MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct iwl_mvm)
1355 #define MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \
1356         _MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct iwl_mvm)
1357 #define MVM_DEBUGFS_ADD_FILE_ALIAS(alias, name, parent, mode) do {      \
1358                 if (!debugfs_create_file(alias, mode, parent, mvm,      \
1359                                          &iwl_dbgfs_##name##_ops))      \
1360                         goto err;                                       \
1361         } while (0)
1362 #define MVM_DEBUGFS_ADD_FILE(name, parent, mode) \
1363         MVM_DEBUGFS_ADD_FILE_ALIAS(#name, name, parent, mode)
1364
1365 static ssize_t
1366 iwl_dbgfs_prph_reg_read(struct file *file,
1367                         char __user *user_buf,
1368                         size_t count, loff_t *ppos)
1369 {
1370         struct iwl_mvm *mvm = file->private_data;
1371         int pos = 0;
1372         char buf[32];
1373         const size_t bufsz = sizeof(buf);
1374         int ret;
1375
1376         if (!mvm->dbgfs_prph_reg_addr)
1377                 return -EINVAL;
1378
1379         ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PRPH_READ);
1380         if (ret)
1381                 return ret;
1382
1383         pos += scnprintf(buf + pos, bufsz - pos, "Reg 0x%x: (0x%x)\n",
1384                 mvm->dbgfs_prph_reg_addr,
1385                 iwl_read_prph(mvm->trans, mvm->dbgfs_prph_reg_addr));
1386
1387         iwl_mvm_unref(mvm, IWL_MVM_REF_PRPH_READ);
1388
1389         return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1390 }
1391
1392 static ssize_t
1393 iwl_dbgfs_prph_reg_write(struct iwl_mvm *mvm, char *buf,
1394                          size_t count, loff_t *ppos)
1395 {
1396         u8 args;
1397         u32 value;
1398         int ret;
1399
1400         args = sscanf(buf, "%i %i", &mvm->dbgfs_prph_reg_addr, &value);
1401         /* if we only want to set the reg address - nothing more to do */
1402         if (args == 1)
1403                 goto out;
1404
1405         /* otherwise, make sure we have both address and value */
1406         if (args != 2)
1407                 return -EINVAL;
1408
1409         ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PRPH_WRITE);
1410         if (ret)
1411                 return ret;
1412
1413         iwl_write_prph(mvm->trans, mvm->dbgfs_prph_reg_addr, value);
1414
1415         iwl_mvm_unref(mvm, IWL_MVM_REF_PRPH_WRITE);
1416 out:
1417         return count;
1418 }
1419
1420 static ssize_t
1421 iwl_dbgfs_send_echo_cmd_write(struct iwl_mvm *mvm, char *buf,
1422                               size_t count, loff_t *ppos)
1423 {
1424         int ret;
1425
1426         mutex_lock(&mvm->mutex);
1427         ret = iwl_mvm_send_cmd_pdu(mvm, ECHO_CMD, 0, 0, NULL);
1428         mutex_unlock(&mvm->mutex);
1429
1430         return ret ?: count;
1431 }
1432
1433 MVM_DEBUGFS_READ_WRITE_FILE_OPS(prph_reg, 64);
1434
1435 /* Device wide debugfs entries */
1436 MVM_DEBUGFS_WRITE_FILE_OPS(tx_flush, 16);
1437 MVM_DEBUGFS_WRITE_FILE_OPS(sta_drain, 8);
1438 MVM_DEBUGFS_WRITE_FILE_OPS(send_echo_cmd, 8);
1439 MVM_DEBUGFS_READ_WRITE_FILE_OPS(sram, 64);
1440 MVM_DEBUGFS_READ_WRITE_FILE_OPS(set_nic_temperature, 64);
1441 MVM_DEBUGFS_READ_FILE_OPS(nic_temp);
1442 MVM_DEBUGFS_READ_FILE_OPS(stations);
1443 MVM_DEBUGFS_READ_FILE_OPS(bt_notif);
1444 MVM_DEBUGFS_READ_FILE_OPS(bt_cmd);
1445 MVM_DEBUGFS_READ_WRITE_FILE_OPS(disable_power_off, 64);
1446 MVM_DEBUGFS_READ_FILE_OPS(fw_rx_stats);
1447 MVM_DEBUGFS_READ_FILE_OPS(drv_rx_stats);
1448 MVM_DEBUGFS_WRITE_FILE_OPS(fw_restart, 10);
1449 MVM_DEBUGFS_WRITE_FILE_OPS(fw_nmi, 10);
1450 MVM_DEBUGFS_WRITE_FILE_OPS(bt_tx_prio, 10);
1451 MVM_DEBUGFS_WRITE_FILE_OPS(bt_force_ant, 10);
1452 MVM_DEBUGFS_READ_WRITE_FILE_OPS(scan_ant_rxchain, 8);
1453 MVM_DEBUGFS_READ_WRITE_FILE_OPS(d0i3_refs, 8);
1454 MVM_DEBUGFS_READ_WRITE_FILE_OPS(fw_dbg_conf, 8);
1455 MVM_DEBUGFS_WRITE_FILE_OPS(fw_dbg_collect, 64);
1456 MVM_DEBUGFS_WRITE_FILE_OPS(cont_recording, 8);
1457
1458 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
1459 MVM_DEBUGFS_READ_WRITE_FILE_OPS(bcast_filters, 256);
1460 MVM_DEBUGFS_READ_WRITE_FILE_OPS(bcast_filters_macs, 256);
1461 #endif
1462
1463 #ifdef CONFIG_PM_SLEEP
1464 MVM_DEBUGFS_READ_WRITE_FILE_OPS(d3_sram, 8);
1465 #endif
1466
1467 int iwl_mvm_dbgfs_register(struct iwl_mvm *mvm, struct dentry *dbgfs_dir)
1468 {
1469         struct dentry *bcast_dir __maybe_unused;
1470         char buf[100];
1471
1472         spin_lock_init(&mvm->drv_stats_lock);
1473
1474         mvm->debugfs_dir = dbgfs_dir;
1475
1476         MVM_DEBUGFS_ADD_FILE(tx_flush, mvm->debugfs_dir, S_IWUSR);
1477         MVM_DEBUGFS_ADD_FILE(sta_drain, mvm->debugfs_dir, S_IWUSR);
1478         MVM_DEBUGFS_ADD_FILE(sram, mvm->debugfs_dir, S_IWUSR | S_IRUSR);
1479         MVM_DEBUGFS_ADD_FILE(set_nic_temperature, mvm->debugfs_dir,
1480                              S_IWUSR | S_IRUSR);
1481         MVM_DEBUGFS_ADD_FILE(nic_temp, dbgfs_dir, S_IRUSR);
1482         MVM_DEBUGFS_ADD_FILE(stations, dbgfs_dir, S_IRUSR);
1483         MVM_DEBUGFS_ADD_FILE(bt_notif, dbgfs_dir, S_IRUSR);
1484         MVM_DEBUGFS_ADD_FILE(bt_cmd, dbgfs_dir, S_IRUSR);
1485         MVM_DEBUGFS_ADD_FILE(disable_power_off, mvm->debugfs_dir,
1486                              S_IRUSR | S_IWUSR);
1487         MVM_DEBUGFS_ADD_FILE(fw_rx_stats, mvm->debugfs_dir, S_IRUSR);
1488         MVM_DEBUGFS_ADD_FILE(drv_rx_stats, mvm->debugfs_dir, S_IRUSR);
1489         MVM_DEBUGFS_ADD_FILE(fw_restart, mvm->debugfs_dir, S_IWUSR);
1490         MVM_DEBUGFS_ADD_FILE(fw_nmi, mvm->debugfs_dir, S_IWUSR);
1491         MVM_DEBUGFS_ADD_FILE(bt_tx_prio, mvm->debugfs_dir, S_IWUSR);
1492         MVM_DEBUGFS_ADD_FILE(bt_force_ant, mvm->debugfs_dir, S_IWUSR);
1493         MVM_DEBUGFS_ADD_FILE(scan_ant_rxchain, mvm->debugfs_dir,
1494                              S_IWUSR | S_IRUSR);
1495         MVM_DEBUGFS_ADD_FILE(prph_reg, mvm->debugfs_dir, S_IWUSR | S_IRUSR);
1496         MVM_DEBUGFS_ADD_FILE(d0i3_refs, mvm->debugfs_dir, S_IRUSR | S_IWUSR);
1497         MVM_DEBUGFS_ADD_FILE(fw_dbg_conf, mvm->debugfs_dir, S_IRUSR | S_IWUSR);
1498         MVM_DEBUGFS_ADD_FILE(fw_dbg_collect, mvm->debugfs_dir, S_IWUSR);
1499         MVM_DEBUGFS_ADD_FILE(send_echo_cmd, mvm->debugfs_dir, S_IWUSR);
1500         MVM_DEBUGFS_ADD_FILE(cont_recording, mvm->debugfs_dir, S_IWUSR);
1501         if (!debugfs_create_bool("enable_scan_iteration_notif",
1502                                  S_IRUSR | S_IWUSR,
1503                                  mvm->debugfs_dir,
1504                                  &mvm->scan_iter_notif_enabled))
1505                 goto err;
1506
1507 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
1508         if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BCAST_FILTERING) {
1509                 bcast_dir = debugfs_create_dir("bcast_filtering",
1510                                                mvm->debugfs_dir);
1511                 if (!bcast_dir)
1512                         goto err;
1513
1514                 if (!debugfs_create_bool("override", S_IRUSR | S_IWUSR,
1515                                 bcast_dir,
1516                                 &mvm->dbgfs_bcast_filtering.override))
1517                         goto err;
1518
1519                 MVM_DEBUGFS_ADD_FILE_ALIAS("filters", bcast_filters,
1520                                            bcast_dir, S_IWUSR | S_IRUSR);
1521                 MVM_DEBUGFS_ADD_FILE_ALIAS("macs", bcast_filters_macs,
1522                                            bcast_dir, S_IWUSR | S_IRUSR);
1523         }
1524 #endif
1525
1526 #ifdef CONFIG_PM_SLEEP
1527         MVM_DEBUGFS_ADD_FILE(d3_sram, mvm->debugfs_dir, S_IRUSR | S_IWUSR);
1528         MVM_DEBUGFS_ADD_FILE(d3_test, mvm->debugfs_dir, S_IRUSR);
1529         if (!debugfs_create_bool("d3_wake_sysassert", S_IRUSR | S_IWUSR,
1530                                  mvm->debugfs_dir, &mvm->d3_wake_sysassert))
1531                 goto err;
1532         if (!debugfs_create_u32("last_netdetect_scans", S_IRUSR,
1533                                 mvm->debugfs_dir, &mvm->last_netdetect_scans))
1534                 goto err;
1535 #endif
1536
1537         if (!debugfs_create_u8("ps_disabled", S_IRUSR,
1538                                mvm->debugfs_dir, &mvm->ps_disabled))
1539                 goto err;
1540         if (!debugfs_create_blob("nvm_hw", S_IRUSR,
1541                                   mvm->debugfs_dir, &mvm->nvm_hw_blob))
1542                 goto err;
1543         if (!debugfs_create_blob("nvm_sw", S_IRUSR,
1544                                   mvm->debugfs_dir, &mvm->nvm_sw_blob))
1545                 goto err;
1546         if (!debugfs_create_blob("nvm_calib", S_IRUSR,
1547                                   mvm->debugfs_dir, &mvm->nvm_calib_blob))
1548                 goto err;
1549         if (!debugfs_create_blob("nvm_prod", S_IRUSR,
1550                                   mvm->debugfs_dir, &mvm->nvm_prod_blob))
1551                 goto err;
1552         if (!debugfs_create_blob("nvm_phy_sku", S_IRUSR,
1553                                  mvm->debugfs_dir, &mvm->nvm_phy_sku_blob))
1554                 goto err;
1555
1556         /*
1557          * Create a symlink with mac80211. It will be removed when mac80211
1558          * exists (before the opmode exists which removes the target.)
1559          */
1560         snprintf(buf, 100, "../../%s/%s",
1561                  dbgfs_dir->d_parent->d_parent->d_name.name,
1562                  dbgfs_dir->d_parent->d_name.name);
1563         if (!debugfs_create_symlink("iwlwifi", mvm->hw->wiphy->debugfsdir, buf))
1564                 goto err;
1565
1566         return 0;
1567 err:
1568         IWL_ERR(mvm, "Can't create the mvm debugfs directory\n");
1569         return -ENOMEM;
1570 }