Lines Matching refs:mvm
13 #include "mvm.h"
26 struct iwl_mvm *mvm = file->private_data;
30 if (!iwl_mvm_is_ctdp_supported(mvm))
33 if (!iwl_mvm_firmware_running(mvm) ||
34 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR)
37 mutex_lock(&mvm->mutex);
38 budget = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_REPORT, 0);
39 mutex_unlock(&mvm->mutex);
49 static ssize_t iwl_dbgfs_stop_ctdp_write(struct iwl_mvm *mvm, char *buf,
56 IWL_DEBUG_INFO(mvm,
64 if (!force && !iwl_mvm_is_ctdp_supported(mvm))
67 if (!iwl_mvm_firmware_running(mvm) ||
68 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR)
71 mutex_lock(&mvm->mutex);
72 ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_STOP, 0);
73 mutex_unlock(&mvm->mutex);
78 static ssize_t iwl_dbgfs_start_ctdp_write(struct iwl_mvm *mvm,
86 IWL_DEBUG_INFO(mvm,
94 if (!force && !iwl_mvm_is_ctdp_supported(mvm))
97 if (!iwl_mvm_firmware_running(mvm) ||
98 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR)
101 mutex_lock(&mvm->mutex);
102 ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START, 0);
103 mutex_unlock(&mvm->mutex);
108 static ssize_t iwl_dbgfs_force_ctkill_write(struct iwl_mvm *mvm, char *buf,
111 if (!iwl_mvm_firmware_running(mvm) ||
112 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR)
115 iwl_mvm_enter_ctkill(mvm);
120 static ssize_t iwl_dbgfs_tx_flush_write(struct iwl_mvm *mvm, char *buf,
126 if (!iwl_mvm_firmware_running(mvm) ||
127 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR)
133 if (iwl_mvm_has_new_tx_api(mvm)) {
134 IWL_DEBUG_TX_QUEUES(mvm,
137 mutex_lock(&mvm->mutex);
138 ret = iwl_mvm_flush_sta_tids(mvm, flush_arg, 0xFFFF)
140 mutex_unlock(&mvm->mutex);
144 IWL_DEBUG_TX_QUEUES(mvm, "FLUSHING queues mask to flush = 0x%x\n",
147 mutex_lock(&mvm->mutex);
148 ret = iwl_mvm_flush_tx_path(mvm, flush_arg) ? : count;
149 mutex_unlock(&mvm->mutex);
157 struct iwl_mvm *mvm = file->private_data;
163 if (!iwl_mvm_firmware_running(mvm))
167 img = &mvm->fw->img[mvm->fwrt.cur_fw_img];
171 if (mvm->dbgfs_sram_len) {
172 ofs = mvm->dbgfs_sram_offset;
173 len = mvm->dbgfs_sram_len;
180 iwl_trans_read_mem_bytes(mvm->trans, ofs, ptr, len);
189 static ssize_t iwl_dbgfs_sram_write(struct iwl_mvm *mvm, char *buf,
196 if (!iwl_mvm_firmware_running(mvm))
199 img = &mvm->fw->img[mvm->fwrt.cur_fw_img];
210 mvm->dbgfs_sram_offset = offset;
211 mvm->dbgfs_sram_len = len;
213 mvm->dbgfs_sram_offset = 0;
214 mvm->dbgfs_sram_len = 0;
224 struct iwl_mvm *mvm = file->private_data;
228 if (!mvm->temperature_test)
231 pos = scnprintf(buf, sizeof(buf), "%d\n", mvm->temperature);
243 static ssize_t iwl_dbgfs_set_nic_temperature_write(struct iwl_mvm *mvm,
249 if (!iwl_mvm_firmware_running(mvm) && !mvm->temperature_test)
260 mutex_lock(&mvm->mutex);
262 if (!mvm->temperature_test)
265 mvm->temperature_test = false;
270 mvm->temperature = 0;
272 mvm->temperature_test = true;
273 mvm->temperature = temperature;
275 IWL_DEBUG_TEMP(mvm, "%sabling debug set temperature (temp = %d)\n",
276 mvm->temperature_test ? "En" : "Dis",
277 mvm->temperature);
279 iwl_mvm_tt_handler(mvm);
282 mutex_unlock(&mvm->mutex);
291 struct iwl_mvm *mvm = file->private_data;
296 if (!iwl_mvm_firmware_running(mvm))
299 mutex_lock(&mvm->mutex);
300 ret = iwl_mvm_get_temp(mvm, &temp);
301 mutex_unlock(&mvm->mutex);
316 struct iwl_mvm *mvm = file->private_data;
322 if (!iwl_mvm_firmware_running(mvm))
325 mutex_lock(&mvm->mutex);
326 tbl_idx = iwl_mvm_get_sar_geo_profile(mvm);
328 mutex_unlock(&mvm->mutex);
340 mvm->fwrt.geo_profiles[tbl_idx - 1].bands[0].chains[0],
341 mvm->fwrt.geo_profiles[tbl_idx - 1].bands[0].chains[1],
342 mvm->fwrt.geo_profiles[tbl_idx - 1].bands[0].max);
345 mvm->fwrt.geo_profiles[tbl_idx - 1].bands[1].chains[0],
346 mvm->fwrt.geo_profiles[tbl_idx - 1].bands[1].chains[1],
347 mvm->fwrt.geo_profiles[tbl_idx - 1].bands[1].max);
349 mutex_unlock(&mvm->mutex);
358 struct iwl_mvm *mvm = file->private_data;
363 err = iwl_bios_get_dsm(&mvm->fwrt, DSM_FUNC_ENABLE_6E, &value);
376 struct iwl_mvm *mvm = file->private_data;
381 mutex_lock(&mvm->mutex);
383 for (i = 0; i < mvm->fw->ucode_capa.num_stations; i++) {
385 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
386 lockdep_is_held(&mvm->mutex));
397 mutex_unlock(&mvm->mutex);
404 struct iwl_mvm *mvm,
429 (iwl_mvm_get_valid_tx_ant(mvm) & ANT_A) ? "ANT_A," : "",
430 (iwl_mvm_get_valid_tx_ant(mvm) & ANT_B) ? "ANT_B," : "");
447 struct iwl_mvm *mvm,
480 struct iwl_mvm *mvm,
500 struct iwl_mvm *mvm = file->private_data;
506 mvm->disable_power_off);
508 mvm->disable_power_off_d3);
513 static ssize_t iwl_dbgfs_disable_power_off_write(struct iwl_mvm *mvm, char *buf,
518 if (!iwl_mvm_firmware_running(mvm))
524 mvm->disable_power_off = val;
528 mvm->disable_power_off_d3 = val;
533 mutex_lock(&mvm->mutex);
534 ret = iwl_mvm_power_update_device(mvm);
535 mutex_unlock(&mvm->mutex);
543 struct iwl_mvm *mvm = file->private_data;
556 mvm->fwrt.fw->fw_version);
558 mvm->fwrt.fw->human_readable);
560 mvm->fwrt.trans->name);
563 mvm->fwrt.dev->bus->name);
578 struct iwl_mvm *mvm = file->private_data;
594 "inactive due to mvm mode",
613 if (!iwl_mvm_firmware_running(mvm))
616 mutex_lock(&mvm->mutex);
617 ret = iwl_mvm_send_cmd(mvm, &hcmd);
618 mutex_unlock(&mvm->mutex);
762 struct iwl_mvm *mvm = file->private_data;
768 bufsz = mvm->fw->phy_integration_ver_len + 2;
773 pos = scnprintf(buf, bufsz, "%.*s\n", mvm->fw->phy_integration_ver_len,
774 mvm->fw->phy_integration_ver);
791 struct iwl_mvm *mvm = file->private_data;
798 u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw,
806 if (iwl_mvm_has_new_rx_stats_api(mvm))
818 mutex_lock(&mvm->mutex);
820 if (iwl_mvm_firmware_running(mvm))
821 iwl_mvm_request_statistics(mvm, false);
825 if (!iwl_mvm_has_new_rx_stats_api(mvm)) {
826 struct mvm_statistics_rx_phy_v2 *ofdm = &mvm->rx_stats_v3.ofdm;
849 struct mvm_statistics_rx_phy *ofdm = &mvm->rx_stats.ofdm;
860 if (!iwl_mvm_has_new_rx_stats_api(mvm)) {
861 struct mvm_statistics_rx_phy_v2 *cck = &mvm->rx_stats_v3.cck;
884 struct mvm_statistics_rx_phy *cck = &mvm->rx_stats.cck;
895 if (!iwl_mvm_has_new_rx_stats_api(mvm)) {
897 &mvm->rx_stats_v3.general;
925 &mvm->rx_stats.general;
951 if (!iwl_mvm_has_new_rx_stats_api(mvm)) {
953 &mvm->rx_stats_v3.ofdm_ht;
967 &mvm->rx_stats.ofdm_ht;
975 mutex_unlock(&mvm->mutex);
994 struct iwl_mvm *mvm = file->private_data;
995 u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw,
1016 mutex_lock(&mvm->mutex);
1017 if (iwl_mvm_firmware_running(mvm))
1018 iwl_mvm_request_statistics(mvm, false);
1021 vif = iwl_mvm_rcu_dereference_vif_id(mvm, i, false);
1058 mvm->radio_stats.rx_time);
1061 mvm->radio_stats.tx_time);
1064 mvm->accu_radio_stats.rx_time);
1067 mvm->accu_radio_stats.tx_time);
1070 mutex_unlock(&mvm->mutex);
1079 static ssize_t iwl_dbgfs_frame_stats_read(struct iwl_mvm *mvm,
1093 spin_lock_bh(&mvm->drv_stats_lock);
1138 spin_unlock_bh(&mvm->drv_stats_lock);
1150 struct iwl_mvm *mvm = file->private_data;
1152 return iwl_dbgfs_frame_stats_read(mvm, user_buf, count, ppos,
1153 &mvm->drv_rx_stats);
1156 static ssize_t iwl_dbgfs_fw_restart_write(struct iwl_mvm *mvm, char *buf,
1161 if (!iwl_mvm_firmware_running(mvm))
1164 mutex_lock(&mvm->mutex);
1167 if (mvm->fw_restart >= 0)
1168 mvm->fw_restart++;
1171 set_bit(IWL_MVM_STATUS_SUPPRESS_ERROR_LOG_ONCE, &mvm->status);
1172 set_bit(STATUS_SUPPRESS_CMD_ERROR_ONCE, &mvm->trans->status);
1176 ret = iwl_mvm_send_cmd_pdu(mvm,
1180 mutex_unlock(&mvm->mutex);
1185 static ssize_t iwl_dbgfs_fw_nmi_write(struct iwl_mvm *mvm, char *buf,
1188 if (!iwl_mvm_firmware_running(mvm))
1191 IWL_ERR(mvm, "Triggering an NMI from debugfs\n");
1194 set_bit(IWL_MVM_STATUS_SUPPRESS_ERROR_LOG_ONCE, &mvm->status);
1196 iwl_force_nmi(mvm->trans);
1206 struct iwl_mvm *mvm = file->private_data;
1213 if (mvm->scan_rx_ant & ANT_A)
1215 if (mvm->scan_rx_ant & ANT_B)
1217 pos += scnprintf(buf + pos, bufsz - pos, " (%x)\n", mvm->scan_rx_ant);
1223 iwl_dbgfs_scan_ant_rxchain_write(struct iwl_mvm *mvm, char *buf,
1228 if (!iwl_mvm_firmware_running(mvm))
1235 if (scan_rx_ant & ~(iwl_mvm_get_valid_rx_ant(mvm)))
1238 if (mvm->scan_rx_ant != scan_rx_ant) {
1239 mvm->scan_rx_ant = scan_rx_ant;
1240 if (fw_has_capa(&mvm->fw->ucode_capa,
1242 iwl_mvm_config_scan(mvm);
1248 static ssize_t iwl_dbgfs_indirection_tbl_write(struct iwl_mvm *mvm,
1284 mutex_lock(&mvm->mutex);
1285 if (iwl_mvm_firmware_running(mvm))
1286 ret = iwl_mvm_send_cmd_pdu(mvm, RSS_CONFIG_CMD, 0,
1290 mutex_unlock(&mvm->mutex);
1295 static ssize_t iwl_dbgfs_inject_packet_write(struct iwl_mvm *mvm,
1299 struct iwl_op_mode *opmode = container_of((void *)mvm,
1311 if (!iwl_mvm_firmware_running(mvm))
1315 if (!mvm->trans->trans_cfg->mq_rx_supported)
1343 static int _iwl_dbgfs_inject_beacon_ie(struct iwl_mvm *mvm, char *bin, int len)
1360 if (!iwl_mvm_firmware_running(mvm))
1363 if (!iwl_mvm_has_new_tx_api(mvm) &&
1364 !fw_has_api(&mvm->fw->ucode_capa,
1368 mutex_lock(&mvm->mutex);
1371 vif = iwl_mvm_rcu_dereference_vif_id(mvm, i, false);
1382 mvm->hw->extra_beacon_tailroom = len;
1384 beacon = ieee80211_beacon_get_template(mvm->hw, vif, NULL, 0);
1393 mvm->beacon_inject_active = true;
1397 rate = iwl_mvm_mac_ctxt_get_beacon_rate(mvm, info, vif);
1401 cpu_to_le16(iwl_mvm_mac_ctxt_get_beacon_flags(mvm->fw,
1404 if (iwl_fw_lookup_cmd_ver(mvm->fw, BEACON_TEMPLATE_CMD, 0) > 12)
1410 iwl_mvm_mac_ctxt_set_tim(mvm, &beacon_cmd.tim_idx,
1414 if (iwl_fw_lookup_cmd_ver(mvm->fw,
1423 iwl_mvm_mac_ctxt_send_beacon_cmd(mvm, beacon, &beacon_cmd,
1426 mutex_unlock(&mvm->mutex);
1433 mutex_unlock(&mvm->mutex);
1437 static ssize_t iwl_dbgfs_inject_beacon_ie_write(struct iwl_mvm *mvm,
1441 int ret = _iwl_dbgfs_inject_beacon_ie(mvm, buf, count);
1443 mvm->hw->extra_beacon_tailroom = 0;
1447 static ssize_t iwl_dbgfs_inject_beacon_ie_restore_write(struct iwl_mvm *mvm,
1452 int ret = _iwl_dbgfs_inject_beacon_ie(mvm, NULL, 0);
1454 mvm->hw->extra_beacon_tailroom = 0;
1455 mvm->beacon_inject_active = false;
1463 struct iwl_mvm *mvm = file->private_data;
1469 mutex_lock(&mvm->mutex);
1470 conf = mvm->fwrt.dump.conf;
1471 mutex_unlock(&mvm->mutex);
1478 static ssize_t iwl_dbgfs_fw_dbg_conf_write(struct iwl_mvm *mvm,
1485 if (!iwl_mvm_firmware_running(mvm))
1495 mutex_lock(&mvm->mutex);
1496 ret = iwl_fw_start_dbg_conf(&mvm->fwrt, conf_id);
1497 mutex_unlock(&mvm->mutex);
1502 static ssize_t iwl_dbgfs_fw_dbg_collect_write(struct iwl_mvm *mvm,
1509 iwl_dbg_tlv_time_point(&mvm->fwrt, IWL_FW_INI_TIME_POINT_USER_TRIGGER,
1512 iwl_fw_dbg_collect(&mvm->fwrt, FW_DBG_TRIGGER_USER, buf,
1518 static ssize_t iwl_dbgfs_fw_dbg_clear_write(struct iwl_mvm *mvm,
1522 if (mvm->trans->trans_cfg->device_family < IWL_DEVICE_FAMILY_9000)
1525 mutex_lock(&mvm->mutex);
1526 iwl_fw_dbg_clear_monitor_buf(&mvm->fwrt);
1527 mutex_unlock(&mvm->mutex);
1532 static ssize_t iwl_dbgfs_dbg_time_point_write(struct iwl_mvm *mvm,
1545 iwl_dbg_tlv_time_point(&mvm->fwrt, timepoint, NULL);
1555 debugfs_create_file(alias, mode, parent, mvm, \
1573 struct iwl_mvm *mvm = iwl_mvm_vif_from_mac80211(mvmsta->vif)->mvm;
1577 mutex_lock(&mvm->mutex);
1580 lockdep_is_held(&mvm->mutex));
1582 mutex_unlock(&mvm->mutex);
1586 ret = real(link_sta, mvmsta, mvm, mvm_link_sta, buf, buf_size, ppos);
1588 mutex_unlock(&mvm->mutex);
1605 struct iwl_mvm *mvm = iwl_mvm_vif_from_mac80211(mvmsta->vif)->mvm;
1609 mutex_lock(&mvm->mutex);
1612 lockdep_is_held(&mvm->mutex));
1614 mutex_unlock(&mvm->mutex);
1618 ret = real(link_sta, mvmsta, mvm, mvm_link_sta, user_buf, count, ppos);
1620 mutex_unlock(&mvm->mutex);
1688 struct iwl_mvm *mvm = file->private_data;
1693 if (!mvm->dbgfs_prph_reg_addr)
1697 mvm->dbgfs_prph_reg_addr,
1698 iwl_read_prph(mvm->trans, mvm->dbgfs_prph_reg_addr));
1704 iwl_dbgfs_prph_reg_write(struct iwl_mvm *mvm, char *buf,
1710 args = sscanf(buf, "%i %i", &mvm->dbgfs_prph_reg_addr, &value);
1719 iwl_write_prph(mvm->trans, mvm->dbgfs_prph_reg_addr, value);
1726 iwl_dbgfs_send_echo_cmd_write(struct iwl_mvm *mvm, char *buf,
1731 if (!iwl_mvm_firmware_running(mvm))
1734 mutex_lock(&mvm->mutex);
1735 ret = iwl_mvm_send_cmd_pdu(mvm, ECHO_CMD, 0, 0, NULL);
1736 mutex_unlock(&mvm->mutex);
1742 struct iwl_mvm *mvm;
1752 apply->mvm->cur_aid = cpu_to_le16(apply->aid);
1753 memcpy(apply->mvm->cur_bssid, apply->bssid,
1754 sizeof(apply->mvm->cur_bssid));
1760 iwl_dbgfs_he_sniffer_params_write(struct iwl_mvm *mvm, char *buf,
1766 .mvm = mvm,
1774 if (!iwl_mvm_firmware_running(mvm))
1789 mutex_lock(&mvm->mutex);
1795 * still have mvm->cur_aid pointing to the old AID, and that
1798 * get mvm->cur_aid correctly set to the new AID.
1800 iwl_init_notification_wait(&mvm->notif_wait, &wait,
1804 ret = iwl_mvm_send_cmd_pdu(mvm,
1810 iwl_remove_notification(&mvm->notif_wait, &wait);
1812 mutex_unlock(&mvm->mutex);
1821 struct iwl_mvm *mvm = file->private_data;
1827 le16_to_cpu(mvm->cur_aid), mvm->cur_bssid[0],
1828 mvm->cur_bssid[1], mvm->cur_bssid[2], mvm->cur_bssid[3],
1829 mvm->cur_bssid[4], mvm->cur_bssid[5]);
1838 struct iwl_mvm *mvm = file->private_data;
1844 mutex_lock(&mvm->mutex);
1848 mvm->uapsd_noagg_bssids[i].addr);
1850 mutex_unlock(&mvm->mutex);
1856 iwl_dbgfs_ltr_config_write(struct iwl_mvm *mvm,
1862 if (!iwl_mvm_firmware_running(mvm))
1876 mutex_lock(&mvm->mutex);
1877 ret = iwl_mvm_send_cmd_pdu(mvm, LTR_CONFIG, 0, sizeof(ltr_config),
1879 mutex_unlock(&mvm->mutex);
1882 IWL_ERR(mvm, "failed to send ltr configuration cmd\n");
1887 static ssize_t iwl_dbgfs_rfi_freq_table_write(struct iwl_mvm *mvm, char *buf,
1898 mutex_lock(&mvm->mutex);
1899 ret = iwl_rfi_send_config_cmd(mvm, NULL);
1900 mutex_unlock(&mvm->mutex);
1920 struct iwl_mvm *mvm = file->private_data;
1926 resp = iwl_rfi_get_freq_table(mvm);
2004 struct iwl_mvm *mvm = file->private_data;
2015 if (!iwl_mvm_firmware_running(mvm))
2027 mutex_lock(&mvm->mutex);
2028 ret = iwl_mvm_send_cmd(mvm, &hcmd);
2029 mutex_unlock(&mvm->mutex);
2065 struct iwl_mvm *mvm = file->private_data;
2074 if (!iwl_mvm_firmware_running(mvm))
2106 mutex_lock(&mvm->mutex);
2107 ret = iwl_mvm_send_cmd(mvm, &hcmd);
2108 mutex_unlock(&mvm->mutex);
2146 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2148 if (iwl_mvm_has_tlc_offload(mvm)) {
2155 void iwl_mvm_dbgfs_register(struct iwl_mvm *mvm)
2159 spin_lock_init(&mvm->drv_stats_lock);
2161 MVM_DEBUGFS_ADD_FILE(tx_flush, mvm->debugfs_dir, 0200);
2162 MVM_DEBUGFS_ADD_FILE(sram, mvm->debugfs_dir, 0600);
2163 MVM_DEBUGFS_ADD_FILE(set_nic_temperature, mvm->debugfs_dir, 0600);
2164 MVM_DEBUGFS_ADD_FILE(nic_temp, mvm->debugfs_dir, 0400);
2165 MVM_DEBUGFS_ADD_FILE(ctdp_budget, mvm->debugfs_dir, 0400);
2166 MVM_DEBUGFS_ADD_FILE(stop_ctdp, mvm->debugfs_dir, 0200);
2167 MVM_DEBUGFS_ADD_FILE(start_ctdp, mvm->debugfs_dir, 0200);
2168 MVM_DEBUGFS_ADD_FILE(force_ctkill, mvm->debugfs_dir, 0200);
2169 MVM_DEBUGFS_ADD_FILE(stations, mvm->debugfs_dir, 0400);
2170 MVM_DEBUGFS_ADD_FILE(disable_power_off, mvm->debugfs_dir, 0600);
2171 MVM_DEBUGFS_ADD_FILE(fw_ver, mvm->debugfs_dir, 0400);
2172 MVM_DEBUGFS_ADD_FILE(fw_rx_stats, mvm->debugfs_dir, 0400);
2173 MVM_DEBUGFS_ADD_FILE(drv_rx_stats, mvm->debugfs_dir, 0400);
2174 MVM_DEBUGFS_ADD_FILE(fw_system_stats, mvm->debugfs_dir, 0400);
2175 MVM_DEBUGFS_ADD_FILE(fw_restart, mvm->debugfs_dir, 0200);
2176 MVM_DEBUGFS_ADD_FILE(fw_nmi, mvm->debugfs_dir, 0200);
2177 MVM_DEBUGFS_ADD_FILE(scan_ant_rxchain, mvm->debugfs_dir, 0600);
2178 MVM_DEBUGFS_ADD_FILE(prph_reg, mvm->debugfs_dir, 0600);
2179 MVM_DEBUGFS_ADD_FILE(fw_dbg_conf, mvm->debugfs_dir, 0600);
2180 MVM_DEBUGFS_ADD_FILE(fw_dbg_collect, mvm->debugfs_dir, 0200);
2181 MVM_DEBUGFS_ADD_FILE(fw_dbg_clear, mvm->debugfs_dir, 0200);
2182 MVM_DEBUGFS_ADD_FILE(dbg_time_point, mvm->debugfs_dir, 0200);
2183 MVM_DEBUGFS_ADD_FILE(send_echo_cmd, mvm->debugfs_dir, 0200);
2184 MVM_DEBUGFS_ADD_FILE(indirection_tbl, mvm->debugfs_dir, 0200);
2185 MVM_DEBUGFS_ADD_FILE(inject_packet, mvm->debugfs_dir, 0200);
2186 MVM_DEBUGFS_ADD_FILE(inject_beacon_ie, mvm->debugfs_dir, 0200);
2187 MVM_DEBUGFS_ADD_FILE(inject_beacon_ie_restore, mvm->debugfs_dir, 0200);
2188 MVM_DEBUGFS_ADD_FILE(rfi_freq_table, mvm->debugfs_dir, 0600);
2190 if (mvm->fw->phy_integration_ver)
2191 MVM_DEBUGFS_ADD_FILE(phy_integration_ver, mvm->debugfs_dir, 0400);
2192 MVM_DEBUGFS_ADD_FILE(tas_get_status, mvm->debugfs_dir, 0400);
2194 MVM_DEBUGFS_ADD_FILE(sar_geo_profile, mvm->debugfs_dir, 0400);
2195 MVM_DEBUGFS_ADD_FILE(wifi_6e_enable, mvm->debugfs_dir, 0400);
2197 MVM_DEBUGFS_ADD_FILE(he_sniffer_params, mvm->debugfs_dir, 0600);
2199 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_SET_LTR_GEN2))
2200 MVM_DEBUGFS_ADD_FILE(ltr_config, mvm->debugfs_dir, 0200);
2203 mvm->debugfs_dir, &mvm->scan_iter_notif_enabled);
2204 debugfs_create_bool("drop_bcn_ap_mode", 0600, mvm->debugfs_dir,
2205 &mvm->drop_bcn_ap_mode);
2207 MVM_DEBUGFS_ADD_FILE(uapsd_noagg_bssids, mvm->debugfs_dir, S_IRUSR);
2210 MVM_DEBUGFS_ADD_FILE(d3_test, mvm->debugfs_dir, 0400);
2211 debugfs_create_bool("d3_wake_sysassert", 0600, mvm->debugfs_dir,
2212 &mvm->d3_wake_sysassert);
2213 debugfs_create_u32("last_netdetect_scans", 0400, mvm->debugfs_dir,
2214 &mvm->last_netdetect_scans);
2217 debugfs_create_u8("ps_disabled", 0400, mvm->debugfs_dir,
2218 &mvm->ps_disabled);
2219 debugfs_create_blob("nvm_hw", 0400, mvm->debugfs_dir,
2220 &mvm->nvm_hw_blob);
2221 debugfs_create_blob("nvm_sw", 0400, mvm->debugfs_dir,
2222 &mvm->nvm_sw_blob);
2223 debugfs_create_blob("nvm_calib", 0400, mvm->debugfs_dir,
2224 &mvm->nvm_calib_blob);
2225 debugfs_create_blob("nvm_prod", 0400, mvm->debugfs_dir,
2226 &mvm->nvm_prod_blob);
2227 debugfs_create_blob("nvm_phy_sku", 0400, mvm->debugfs_dir,
2228 &mvm->nvm_phy_sku_blob);
2230 mvm->debugfs_dir, &mvm->nvm_reg_blob);
2232 debugfs_create_file("mem", 0600, mvm->debugfs_dir, mvm,
2235 debugfs_create_bool("rx_ts_ptp", 0600, mvm->debugfs_dir,
2236 &mvm->rx_ts_ptp);
2243 if (!IS_ERR(mvm->debugfs_dir)) {
2246 snprintf(buf, 100, "../../%pd2", mvm->debugfs_dir->d_parent);
2247 debugfs_create_symlink("iwlwifi", mvm->hw->wiphy->debugfsdir,