1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright (C) 2012-2014, 2018-2024 Intel Corporation 4 * Copyright (C) 2013-2015 Intel Mobile Communications GmbH 5 * Copyright (C) 2016-2017 Intel Deutschland GmbH 6 */ 7 #include "mvm.h" 8 #include "debugfs.h" 9 10 static void iwl_dbgfs_update_pm(struct iwl_mvm *mvm, 11 struct ieee80211_vif *vif, 12 enum iwl_dbgfs_pm_mask param, int val) 13 { 14 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 15 struct iwl_dbgfs_pm *dbgfs_pm = &mvmvif->dbgfs_pm; 16 17 dbgfs_pm->mask |= param; 18 19 switch (param) { 20 case MVM_DEBUGFS_PM_KEEP_ALIVE: { 21 int dtimper = vif->bss_conf.dtim_period ?: 1; 22 int dtimper_msec = dtimper * vif->bss_conf.beacon_int; 23 24 IWL_DEBUG_POWER(mvm, "debugfs: set keep_alive= %d sec\n", val); 25 if (val * MSEC_PER_SEC < 3 * dtimper_msec) 26 IWL_WARN(mvm, 27 "debugfs: keep alive period (%ld msec) is less than minimum required (%d msec)\n", 28 val * MSEC_PER_SEC, 3 * dtimper_msec); 29 dbgfs_pm->keep_alive_seconds = val; 30 break; 31 } 32 case MVM_DEBUGFS_PM_SKIP_OVER_DTIM: 33 IWL_DEBUG_POWER(mvm, "skip_over_dtim %s\n", 34 val ? "enabled" : "disabled"); 35 dbgfs_pm->skip_over_dtim = val; 36 break; 37 case MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS: 38 IWL_DEBUG_POWER(mvm, "skip_dtim_periods=%d\n", val); 39 dbgfs_pm->skip_dtim_periods = val; 40 break; 41 case MVM_DEBUGFS_PM_RX_DATA_TIMEOUT: 42 IWL_DEBUG_POWER(mvm, "rx_data_timeout=%d\n", val); 43 dbgfs_pm->rx_data_timeout = val; 44 break; 45 case MVM_DEBUGFS_PM_TX_DATA_TIMEOUT: 46 IWL_DEBUG_POWER(mvm, "tx_data_timeout=%d\n", val); 47 dbgfs_pm->tx_data_timeout = val; 48 break; 49 case MVM_DEBUGFS_PM_LPRX_ENA: 50 IWL_DEBUG_POWER(mvm, "lprx %s\n", val ? "enabled" : "disabled"); 51 dbgfs_pm->lprx_ena = val; 52 break; 53 case MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD: 54 IWL_DEBUG_POWER(mvm, "lprx_rssi_threshold=%d\n", val); 55 dbgfs_pm->lprx_rssi_threshold = val; 56 break; 57 case MVM_DEBUGFS_PM_SNOOZE_ENABLE: 58 IWL_DEBUG_POWER(mvm, "snooze_enable=%d\n", val); 59 dbgfs_pm->snooze_ena = val; 60 break; 61 case MVM_DEBUGFS_PM_UAPSD_MISBEHAVING: 62 IWL_DEBUG_POWER(mvm, "uapsd_misbehaving_enable=%d\n", val); 63 dbgfs_pm->uapsd_misbehaving = val; 64 break; 65 case MVM_DEBUGFS_PM_USE_PS_POLL: 66 IWL_DEBUG_POWER(mvm, "use_ps_poll=%d\n", val); 67 dbgfs_pm->use_ps_poll = val; 68 break; 69 } 70 } 71 72 static ssize_t iwl_dbgfs_pm_params_write(struct ieee80211_vif *vif, char *buf, 73 size_t count, loff_t *ppos) 74 { 75 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 76 struct iwl_mvm *mvm = mvmvif->mvm; 77 enum iwl_dbgfs_pm_mask param; 78 int val, ret; 79 80 if (!strncmp("keep_alive=", buf, 11)) { 81 if (sscanf(buf + 11, "%d", &val) != 1) 82 return -EINVAL; 83 param = MVM_DEBUGFS_PM_KEEP_ALIVE; 84 } else if (!strncmp("skip_over_dtim=", buf, 15)) { 85 if (sscanf(buf + 15, "%d", &val) != 1) 86 return -EINVAL; 87 param = MVM_DEBUGFS_PM_SKIP_OVER_DTIM; 88 } else if (!strncmp("skip_dtim_periods=", buf, 18)) { 89 if (sscanf(buf + 18, "%d", &val) != 1) 90 return -EINVAL; 91 param = MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS; 92 } else if (!strncmp("rx_data_timeout=", buf, 16)) { 93 if (sscanf(buf + 16, "%d", &val) != 1) 94 return -EINVAL; 95 param = MVM_DEBUGFS_PM_RX_DATA_TIMEOUT; 96 } else if (!strncmp("tx_data_timeout=", buf, 16)) { 97 if (sscanf(buf + 16, "%d", &val) != 1) 98 return -EINVAL; 99 param = MVM_DEBUGFS_PM_TX_DATA_TIMEOUT; 100 } else if (!strncmp("lprx=", buf, 5)) { 101 if (sscanf(buf + 5, "%d", &val) != 1) 102 return -EINVAL; 103 param = MVM_DEBUGFS_PM_LPRX_ENA; 104 } else if (!strncmp("lprx_rssi_threshold=", buf, 20)) { 105 if (sscanf(buf + 20, "%d", &val) != 1) 106 return -EINVAL; 107 if (val > POWER_LPRX_RSSI_THRESHOLD_MAX || val < 108 POWER_LPRX_RSSI_THRESHOLD_MIN) 109 return -EINVAL; 110 param = MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD; 111 } else if (!strncmp("snooze_enable=", buf, 14)) { 112 if (sscanf(buf + 14, "%d", &val) != 1) 113 return -EINVAL; 114 param = MVM_DEBUGFS_PM_SNOOZE_ENABLE; 115 } else if (!strncmp("uapsd_misbehaving=", buf, 18)) { 116 if (sscanf(buf + 18, "%d", &val) != 1) 117 return -EINVAL; 118 param = MVM_DEBUGFS_PM_UAPSD_MISBEHAVING; 119 } else if (!strncmp("use_ps_poll=", buf, 12)) { 120 if (sscanf(buf + 12, "%d", &val) != 1) 121 return -EINVAL; 122 param = MVM_DEBUGFS_PM_USE_PS_POLL; 123 } else { 124 return -EINVAL; 125 } 126 127 mutex_lock(&mvm->mutex); 128 iwl_dbgfs_update_pm(mvm, vif, param, val); 129 ret = iwl_mvm_power_update_mac(mvm); 130 mutex_unlock(&mvm->mutex); 131 132 return ret ?: count; 133 } 134 135 static ssize_t iwl_dbgfs_tx_pwr_lmt_read(struct file *file, 136 char __user *user_buf, 137 size_t count, loff_t *ppos) 138 { 139 struct ieee80211_vif *vif = file->private_data; 140 char buf[64]; 141 int bufsz = sizeof(buf); 142 int pos; 143 144 pos = scnprintf(buf, bufsz, "bss limit = %d\n", 145 vif->bss_conf.txpower); 146 147 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 148 } 149 150 static ssize_t iwl_dbgfs_pm_params_read(struct file *file, 151 char __user *user_buf, 152 size_t count, loff_t *ppos) 153 { 154 struct ieee80211_vif *vif = file->private_data; 155 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 156 struct iwl_mvm *mvm = mvmvif->mvm; 157 char buf[512]; 158 int bufsz = sizeof(buf); 159 int pos; 160 161 pos = iwl_mvm_power_mac_dbgfs_read(mvm, vif, buf, bufsz); 162 163 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 164 } 165 166 static ssize_t iwl_dbgfs_mac_params_read(struct file *file, 167 char __user *user_buf, 168 size_t count, loff_t *ppos) 169 { 170 struct ieee80211_vif *vif = file->private_data; 171 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 172 struct iwl_mvm *mvm = mvmvif->mvm; 173 u8 ap_sta_id; 174 struct ieee80211_chanctx_conf *chanctx_conf; 175 char buf[512]; 176 int bufsz = sizeof(buf); 177 int pos = 0; 178 int i; 179 180 mutex_lock(&mvm->mutex); 181 182 ap_sta_id = mvmvif->deflink.ap_sta_id; 183 184 switch (ieee80211_vif_type_p2p(vif)) { 185 case NL80211_IFTYPE_ADHOC: 186 pos += scnprintf(buf+pos, bufsz-pos, "type: ibss\n"); 187 break; 188 case NL80211_IFTYPE_STATION: 189 pos += scnprintf(buf+pos, bufsz-pos, "type: bss\n"); 190 break; 191 case NL80211_IFTYPE_AP: 192 pos += scnprintf(buf+pos, bufsz-pos, "type: ap\n"); 193 break; 194 case NL80211_IFTYPE_P2P_CLIENT: 195 pos += scnprintf(buf+pos, bufsz-pos, "type: p2p client\n"); 196 break; 197 case NL80211_IFTYPE_P2P_GO: 198 pos += scnprintf(buf+pos, bufsz-pos, "type: p2p go\n"); 199 break; 200 case NL80211_IFTYPE_P2P_DEVICE: 201 pos += scnprintf(buf+pos, bufsz-pos, "type: p2p dev\n"); 202 break; 203 default: 204 break; 205 } 206 207 pos += scnprintf(buf+pos, bufsz-pos, "mac id/color: %d / %d\n", 208 mvmvif->id, mvmvif->color); 209 pos += scnprintf(buf+pos, bufsz-pos, "bssid: %pM\n", 210 vif->bss_conf.bssid); 211 pos += scnprintf(buf+pos, bufsz-pos, "Load: %d\n", 212 mvm->tcm.result.load[mvmvif->id]); 213 pos += scnprintf(buf+pos, bufsz-pos, "QoS:\n"); 214 for (i = 0; i < ARRAY_SIZE(mvmvif->deflink.queue_params); i++) 215 pos += scnprintf(buf+pos, bufsz-pos, 216 "\t%d: txop:%d - cw_min:%d - cw_max = %d - aifs = %d upasd = %d\n", 217 i, mvmvif->deflink.queue_params[i].txop, 218 mvmvif->deflink.queue_params[i].cw_min, 219 mvmvif->deflink.queue_params[i].cw_max, 220 mvmvif->deflink.queue_params[i].aifs, 221 mvmvif->deflink.queue_params[i].uapsd); 222 223 if (vif->type == NL80211_IFTYPE_STATION && 224 ap_sta_id != IWL_INVALID_STA) { 225 struct iwl_mvm_sta *mvm_sta; 226 227 mvm_sta = iwl_mvm_sta_from_staid_protected(mvm, ap_sta_id); 228 if (mvm_sta) { 229 pos += scnprintf(buf+pos, bufsz-pos, 230 "ap_sta_id %d - reduced Tx power %d\n", 231 ap_sta_id, 232 mvm_sta->bt_reduced_txpower); 233 } 234 } 235 236 rcu_read_lock(); 237 chanctx_conf = rcu_dereference(vif->bss_conf.chanctx_conf); 238 if (chanctx_conf) 239 pos += scnprintf(buf+pos, bufsz-pos, 240 "idle rx chains %d, active rx chains: %d\n", 241 chanctx_conf->rx_chains_static, 242 chanctx_conf->rx_chains_dynamic); 243 rcu_read_unlock(); 244 245 mutex_unlock(&mvm->mutex); 246 247 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 248 } 249 250 static void iwl_dbgfs_update_bf(struct ieee80211_vif *vif, 251 enum iwl_dbgfs_bf_mask param, int value) 252 { 253 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 254 struct iwl_dbgfs_bf *dbgfs_bf = &mvmvif->dbgfs_bf; 255 256 dbgfs_bf->mask |= param; 257 258 switch (param) { 259 case MVM_DEBUGFS_BF_ENERGY_DELTA: 260 dbgfs_bf->bf_energy_delta = value; 261 break; 262 case MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA: 263 dbgfs_bf->bf_roaming_energy_delta = value; 264 break; 265 case MVM_DEBUGFS_BF_ROAMING_STATE: 266 dbgfs_bf->bf_roaming_state = value; 267 break; 268 case MVM_DEBUGFS_BF_TEMP_THRESHOLD: 269 dbgfs_bf->bf_temp_threshold = value; 270 break; 271 case MVM_DEBUGFS_BF_TEMP_FAST_FILTER: 272 dbgfs_bf->bf_temp_fast_filter = value; 273 break; 274 case MVM_DEBUGFS_BF_TEMP_SLOW_FILTER: 275 dbgfs_bf->bf_temp_slow_filter = value; 276 break; 277 case MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER: 278 dbgfs_bf->bf_enable_beacon_filter = value; 279 break; 280 case MVM_DEBUGFS_BF_DEBUG_FLAG: 281 dbgfs_bf->bf_debug_flag = value; 282 break; 283 case MVM_DEBUGFS_BF_ESCAPE_TIMER: 284 dbgfs_bf->bf_escape_timer = value; 285 break; 286 case MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT: 287 dbgfs_bf->ba_enable_beacon_abort = value; 288 break; 289 case MVM_DEBUGFS_BA_ESCAPE_TIMER: 290 dbgfs_bf->ba_escape_timer = value; 291 break; 292 } 293 } 294 295 static ssize_t iwl_dbgfs_bf_params_write(struct ieee80211_vif *vif, char *buf, 296 size_t count, loff_t *ppos) 297 { 298 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 299 struct iwl_mvm *mvm = mvmvif->mvm; 300 enum iwl_dbgfs_bf_mask param; 301 int value, ret = 0; 302 303 if (!strncmp("bf_energy_delta=", buf, 16)) { 304 if (sscanf(buf+16, "%d", &value) != 1) 305 return -EINVAL; 306 if (value < IWL_BF_ENERGY_DELTA_MIN || 307 value > IWL_BF_ENERGY_DELTA_MAX) 308 return -EINVAL; 309 param = MVM_DEBUGFS_BF_ENERGY_DELTA; 310 } else if (!strncmp("bf_roaming_energy_delta=", buf, 24)) { 311 if (sscanf(buf+24, "%d", &value) != 1) 312 return -EINVAL; 313 if (value < IWL_BF_ROAMING_ENERGY_DELTA_MIN || 314 value > IWL_BF_ROAMING_ENERGY_DELTA_MAX) 315 return -EINVAL; 316 param = MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA; 317 } else if (!strncmp("bf_roaming_state=", buf, 17)) { 318 if (sscanf(buf+17, "%d", &value) != 1) 319 return -EINVAL; 320 if (value < IWL_BF_ROAMING_STATE_MIN || 321 value > IWL_BF_ROAMING_STATE_MAX) 322 return -EINVAL; 323 param = MVM_DEBUGFS_BF_ROAMING_STATE; 324 } else if (!strncmp("bf_temp_threshold=", buf, 18)) { 325 if (sscanf(buf+18, "%d", &value) != 1) 326 return -EINVAL; 327 if (value < IWL_BF_TEMP_THRESHOLD_MIN || 328 value > IWL_BF_TEMP_THRESHOLD_MAX) 329 return -EINVAL; 330 param = MVM_DEBUGFS_BF_TEMP_THRESHOLD; 331 } else if (!strncmp("bf_temp_fast_filter=", buf, 20)) { 332 if (sscanf(buf+20, "%d", &value) != 1) 333 return -EINVAL; 334 if (value < IWL_BF_TEMP_FAST_FILTER_MIN || 335 value > IWL_BF_TEMP_FAST_FILTER_MAX) 336 return -EINVAL; 337 param = MVM_DEBUGFS_BF_TEMP_FAST_FILTER; 338 } else if (!strncmp("bf_temp_slow_filter=", buf, 20)) { 339 if (sscanf(buf+20, "%d", &value) != 1) 340 return -EINVAL; 341 if (value < IWL_BF_TEMP_SLOW_FILTER_MIN || 342 value > IWL_BF_TEMP_SLOW_FILTER_MAX) 343 return -EINVAL; 344 param = MVM_DEBUGFS_BF_TEMP_SLOW_FILTER; 345 } else if (!strncmp("bf_enable_beacon_filter=", buf, 24)) { 346 if (sscanf(buf+24, "%d", &value) != 1) 347 return -EINVAL; 348 if (value < 0 || value > 1) 349 return -EINVAL; 350 param = MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER; 351 } else if (!strncmp("bf_debug_flag=", buf, 14)) { 352 if (sscanf(buf+14, "%d", &value) != 1) 353 return -EINVAL; 354 if (value < 0 || value > 1) 355 return -EINVAL; 356 param = MVM_DEBUGFS_BF_DEBUG_FLAG; 357 } else if (!strncmp("bf_escape_timer=", buf, 16)) { 358 if (sscanf(buf+16, "%d", &value) != 1) 359 return -EINVAL; 360 if (value < IWL_BF_ESCAPE_TIMER_MIN || 361 value > IWL_BF_ESCAPE_TIMER_MAX) 362 return -EINVAL; 363 param = MVM_DEBUGFS_BF_ESCAPE_TIMER; 364 } else if (!strncmp("ba_escape_timer=", buf, 16)) { 365 if (sscanf(buf+16, "%d", &value) != 1) 366 return -EINVAL; 367 if (value < IWL_BA_ESCAPE_TIMER_MIN || 368 value > IWL_BA_ESCAPE_TIMER_MAX) 369 return -EINVAL; 370 param = MVM_DEBUGFS_BA_ESCAPE_TIMER; 371 } else if (!strncmp("ba_enable_beacon_abort=", buf, 23)) { 372 if (sscanf(buf+23, "%d", &value) != 1) 373 return -EINVAL; 374 if (value < 0 || value > 1) 375 return -EINVAL; 376 param = MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT; 377 } else { 378 return -EINVAL; 379 } 380 381 mutex_lock(&mvm->mutex); 382 iwl_dbgfs_update_bf(vif, param, value); 383 if (param == MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER && !value) 384 ret = iwl_mvm_disable_beacon_filter(mvm, vif); 385 else 386 ret = iwl_mvm_enable_beacon_filter(mvm, vif); 387 mutex_unlock(&mvm->mutex); 388 389 return ret ?: count; 390 } 391 392 static ssize_t iwl_dbgfs_bf_params_read(struct file *file, 393 char __user *user_buf, 394 size_t count, loff_t *ppos) 395 { 396 struct ieee80211_vif *vif = file->private_data; 397 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 398 char buf[256]; 399 int pos = 0; 400 const size_t bufsz = sizeof(buf); 401 struct iwl_beacon_filter_cmd cmd = { 402 IWL_BF_CMD_CONFIG_DEFAULTS, 403 .bf_enable_beacon_filter = 404 cpu_to_le32(IWL_BF_ENABLE_BEACON_FILTER_DEFAULT), 405 .ba_enable_beacon_abort = 406 cpu_to_le32(IWL_BA_ENABLE_BEACON_ABORT_DEFAULT), 407 }; 408 409 iwl_mvm_beacon_filter_debugfs_parameters(vif, &cmd); 410 if (mvmvif->bf_enabled) 411 cmd.bf_enable_beacon_filter = cpu_to_le32(1); 412 else 413 cmd.bf_enable_beacon_filter = 0; 414 415 pos += scnprintf(buf+pos, bufsz-pos, "bf_energy_delta = %d\n", 416 le32_to_cpu(cmd.bf_energy_delta)); 417 pos += scnprintf(buf+pos, bufsz-pos, "bf_roaming_energy_delta = %d\n", 418 le32_to_cpu(cmd.bf_roaming_energy_delta)); 419 pos += scnprintf(buf+pos, bufsz-pos, "bf_roaming_state = %d\n", 420 le32_to_cpu(cmd.bf_roaming_state)); 421 pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_threshold = %d\n", 422 le32_to_cpu(cmd.bf_temp_threshold)); 423 pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_fast_filter = %d\n", 424 le32_to_cpu(cmd.bf_temp_fast_filter)); 425 pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_slow_filter = %d\n", 426 le32_to_cpu(cmd.bf_temp_slow_filter)); 427 pos += scnprintf(buf+pos, bufsz-pos, "bf_enable_beacon_filter = %d\n", 428 le32_to_cpu(cmd.bf_enable_beacon_filter)); 429 pos += scnprintf(buf+pos, bufsz-pos, "bf_debug_flag = %d\n", 430 le32_to_cpu(cmd.bf_debug_flag)); 431 pos += scnprintf(buf+pos, bufsz-pos, "bf_escape_timer = %d\n", 432 le32_to_cpu(cmd.bf_escape_timer)); 433 pos += scnprintf(buf+pos, bufsz-pos, "ba_escape_timer = %d\n", 434 le32_to_cpu(cmd.ba_escape_timer)); 435 pos += scnprintf(buf+pos, bufsz-pos, "ba_enable_beacon_abort = %d\n", 436 le32_to_cpu(cmd.ba_enable_beacon_abort)); 437 438 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 439 } 440 441 static ssize_t iwl_dbgfs_os_device_timediff_read(struct file *file, 442 char __user *user_buf, 443 size_t count, loff_t *ppos) 444 { 445 struct ieee80211_vif *vif = file->private_data; 446 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 447 struct iwl_mvm *mvm = mvmvif->mvm; 448 u32 curr_gp2; 449 u64 curr_os; 450 s64 diff; 451 char buf[64]; 452 const size_t bufsz = sizeof(buf); 453 int pos = 0; 454 455 mutex_lock(&mvm->mutex); 456 iwl_mvm_get_sync_time(mvm, CLOCK_BOOTTIME, &curr_gp2, &curr_os, NULL); 457 mutex_unlock(&mvm->mutex); 458 459 do_div(curr_os, NSEC_PER_USEC); 460 diff = curr_os - curr_gp2; 461 pos += scnprintf(buf + pos, bufsz - pos, "diff=%lld\n", diff); 462 463 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 464 } 465 466 static ssize_t 467 iwl_dbgfs_low_latency_write_handle(struct wiphy *wiphy, struct file *file, 468 char *buf, size_t count, void *data) 469 { 470 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 471 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 472 struct ieee80211_vif *vif = data; 473 u8 value; 474 int ret; 475 476 ret = kstrtou8(buf, 0, &value); 477 if (ret) 478 return ret; 479 if (value > 1) 480 return -EINVAL; 481 482 mutex_lock(&mvm->mutex); 483 iwl_mvm_update_low_latency(mvm, vif, value, LOW_LATENCY_DEBUGFS); 484 mutex_unlock(&mvm->mutex); 485 486 return count; 487 } 488 489 static ssize_t iwl_dbgfs_low_latency_write(struct file *file, 490 const char __user *user_buf, 491 size_t count, loff_t *ppos) 492 { 493 struct ieee80211_vif *vif = file->private_data; 494 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 495 struct iwl_mvm *mvm = mvmvif->mvm; 496 char buf[10] = {}; 497 498 return wiphy_locked_debugfs_write(mvm->hw->wiphy, file, 499 buf, sizeof(buf), user_buf, count, 500 iwl_dbgfs_low_latency_write_handle, 501 vif); 502 } 503 504 static ssize_t 505 iwl_dbgfs_low_latency_force_write_handle(struct wiphy *wiphy, struct file *file, 506 char *buf, size_t count, void *data) 507 { 508 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 509 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 510 struct ieee80211_vif *vif = data; 511 u8 value; 512 int ret; 513 514 ret = kstrtou8(buf, 0, &value); 515 if (ret) 516 return ret; 517 518 if (value > NUM_LOW_LATENCY_FORCE) 519 return -EINVAL; 520 521 mutex_lock(&mvm->mutex); 522 if (value == LOW_LATENCY_FORCE_UNSET) { 523 iwl_mvm_update_low_latency(mvm, vif, false, 524 LOW_LATENCY_DEBUGFS_FORCE); 525 iwl_mvm_update_low_latency(mvm, vif, false, 526 LOW_LATENCY_DEBUGFS_FORCE_ENABLE); 527 } else { 528 iwl_mvm_update_low_latency(mvm, vif, 529 value == LOW_LATENCY_FORCE_ON, 530 LOW_LATENCY_DEBUGFS_FORCE); 531 iwl_mvm_update_low_latency(mvm, vif, true, 532 LOW_LATENCY_DEBUGFS_FORCE_ENABLE); 533 } 534 mutex_unlock(&mvm->mutex); 535 return count; 536 } 537 538 static ssize_t 539 iwl_dbgfs_low_latency_force_write(struct file *file, 540 const char __user *user_buf, 541 size_t count, loff_t *ppos) 542 { 543 struct ieee80211_vif *vif = file->private_data; 544 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 545 struct iwl_mvm *mvm = mvmvif->mvm; 546 char buf[10] = {}; 547 548 return wiphy_locked_debugfs_write(mvm->hw->wiphy, file, 549 buf, sizeof(buf), user_buf, count, 550 iwl_dbgfs_low_latency_force_write_handle, 551 vif); 552 } 553 554 static ssize_t iwl_dbgfs_low_latency_read(struct file *file, 555 char __user *user_buf, 556 size_t count, loff_t *ppos) 557 { 558 struct ieee80211_vif *vif = file->private_data; 559 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 560 char format[] = "traffic=%d\ndbgfs=%d\nvcmd=%d\nvif_type=%d\n" 561 "dbgfs_force_enable=%d\ndbgfs_force=%d\nactual=%d\n"; 562 563 /* 564 * all values in format are boolean so the size of format is enough 565 * for holding the result string 566 */ 567 char buf[sizeof(format) + 1] = {}; 568 int len; 569 570 len = scnprintf(buf, sizeof(buf) - 1, format, 571 !!(mvmvif->low_latency & LOW_LATENCY_TRAFFIC), 572 !!(mvmvif->low_latency & LOW_LATENCY_DEBUGFS), 573 !!(mvmvif->low_latency & LOW_LATENCY_VCMD), 574 !!(mvmvif->low_latency & LOW_LATENCY_VIF_TYPE), 575 !!(mvmvif->low_latency & 576 LOW_LATENCY_DEBUGFS_FORCE_ENABLE), 577 !!(mvmvif->low_latency & LOW_LATENCY_DEBUGFS_FORCE), 578 !!(mvmvif->low_latency_actual)); 579 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 580 } 581 582 static ssize_t iwl_dbgfs_uapsd_misbehaving_read(struct file *file, 583 char __user *user_buf, 584 size_t count, loff_t *ppos) 585 { 586 struct ieee80211_vif *vif = file->private_data; 587 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 588 char buf[20]; 589 int len; 590 591 len = sprintf(buf, "%pM\n", mvmvif->uapsd_misbehaving_ap_addr); 592 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 593 } 594 595 static ssize_t iwl_dbgfs_uapsd_misbehaving_write(struct ieee80211_vif *vif, 596 char *buf, size_t count, 597 loff_t *ppos) 598 { 599 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 600 struct iwl_mvm *mvm = mvmvif->mvm; 601 bool ret; 602 603 mutex_lock(&mvm->mutex); 604 ret = mac_pton(buf, mvmvif->uapsd_misbehaving_ap_addr); 605 mutex_unlock(&mvm->mutex); 606 607 return ret ? count : -EINVAL; 608 } 609 610 static ssize_t iwl_dbgfs_rx_phyinfo_write(struct ieee80211_vif *vif, char *buf, 611 size_t count, loff_t *ppos) 612 { 613 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 614 struct iwl_mvm *mvm = mvmvif->mvm; 615 struct ieee80211_bss_conf *link_conf; 616 u16 value; 617 int link_id, ret = -EINVAL; 618 619 ret = kstrtou16(buf, 0, &value); 620 if (ret) 621 return ret; 622 623 mutex_lock(&mvm->mutex); 624 625 mvm->dbgfs_rx_phyinfo = value; 626 627 for_each_vif_active_link(vif, link_conf, link_id) { 628 struct ieee80211_chanctx_conf *chanctx_conf; 629 struct cfg80211_chan_def min_def, ap_def; 630 struct iwl_mvm_phy_ctxt *phy_ctxt; 631 u8 chains_static, chains_dynamic; 632 633 rcu_read_lock(); 634 chanctx_conf = rcu_dereference(link_conf->chanctx_conf); 635 if (!chanctx_conf) { 636 rcu_read_unlock(); 637 continue; 638 } 639 /* A command can't be sent with RCU lock held, so copy 640 * everything here and use it after unlocking 641 */ 642 min_def = chanctx_conf->min_def; 643 ap_def = chanctx_conf->ap; 644 chains_static = chanctx_conf->rx_chains_static; 645 chains_dynamic = chanctx_conf->rx_chains_dynamic; 646 rcu_read_unlock(); 647 648 phy_ctxt = mvmvif->link[link_id]->phy_ctxt; 649 if (!phy_ctxt) 650 continue; 651 652 ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &min_def, &ap_def, 653 chains_static, chains_dynamic); 654 } 655 656 mutex_unlock(&mvm->mutex); 657 658 return ret ?: count; 659 } 660 661 static ssize_t iwl_dbgfs_rx_phyinfo_read(struct file *file, 662 char __user *user_buf, 663 size_t count, loff_t *ppos) 664 { 665 struct ieee80211_vif *vif = file->private_data; 666 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 667 char buf[8]; 668 int len; 669 670 len = scnprintf(buf, sizeof(buf), "0x%04x\n", 671 mvmvif->mvm->dbgfs_rx_phyinfo); 672 673 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 674 } 675 676 static void iwl_dbgfs_quota_check(void *data, u8 *mac, 677 struct ieee80211_vif *vif) 678 { 679 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 680 int *ret = data; 681 682 if (mvmvif->dbgfs_quota_min) 683 *ret = -EINVAL; 684 } 685 686 static ssize_t iwl_dbgfs_quota_min_write(struct ieee80211_vif *vif, char *buf, 687 size_t count, loff_t *ppos) 688 { 689 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 690 struct iwl_mvm *mvm = mvmvif->mvm; 691 u16 value; 692 int ret; 693 694 ret = kstrtou16(buf, 0, &value); 695 if (ret) 696 return ret; 697 698 if (value > 95) 699 return -EINVAL; 700 701 mutex_lock(&mvm->mutex); 702 703 mvmvif->dbgfs_quota_min = 0; 704 ieee80211_iterate_interfaces(mvm->hw, IEEE80211_IFACE_ITER_NORMAL, 705 iwl_dbgfs_quota_check, &ret); 706 if (ret == 0) { 707 mvmvif->dbgfs_quota_min = value; 708 iwl_mvm_update_quotas(mvm, false, NULL); 709 } 710 mutex_unlock(&mvm->mutex); 711 712 return ret ?: count; 713 } 714 715 static ssize_t iwl_dbgfs_quota_min_read(struct file *file, 716 char __user *user_buf, 717 size_t count, loff_t *ppos) 718 { 719 struct ieee80211_vif *vif = file->private_data; 720 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 721 char buf[10]; 722 int len; 723 724 len = scnprintf(buf, sizeof(buf), "%d\n", mvmvif->dbgfs_quota_min); 725 726 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 727 } 728 729 static ssize_t iwl_dbgfs_max_tx_op_write(struct ieee80211_vif *vif, char *buf, 730 size_t count, loff_t *ppos) 731 { 732 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 733 struct iwl_mvm *mvm = mvmvif->mvm; 734 u16 value; 735 int ret; 736 737 ret = kstrtou16(buf, 0, &value); 738 if (ret) 739 return ret; 740 741 mutex_lock(&mvm->mutex); 742 mvmvif->max_tx_op = value; 743 mutex_unlock(&mvm->mutex); 744 745 return count; 746 } 747 748 static ssize_t iwl_dbgfs_max_tx_op_read(struct file *file, 749 char __user *user_buf, 750 size_t count, loff_t *ppos) 751 { 752 struct ieee80211_vif *vif = file->private_data; 753 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 754 struct iwl_mvm *mvm = mvmvif->mvm; 755 char buf[10]; 756 int len; 757 758 mutex_lock(&mvm->mutex); 759 len = scnprintf(buf, sizeof(buf), "%hu\n", mvmvif->max_tx_op); 760 mutex_unlock(&mvm->mutex); 761 762 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 763 } 764 765 static ssize_t iwl_dbgfs_int_mlo_scan_write(struct ieee80211_vif *vif, 766 char *buf, size_t count, 767 loff_t *ppos) 768 { 769 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 770 struct iwl_mvm *mvm = mvmvif->mvm; 771 u32 action; 772 int ret; 773 774 if (!vif->cfg.assoc || !ieee80211_vif_is_mld(vif)) 775 return -EINVAL; 776 777 if (kstrtou32(buf, 0, &action)) 778 return -EINVAL; 779 780 mutex_lock(&mvm->mutex); 781 782 if (!action) { 783 ret = iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_INT_MLO, false); 784 } else if (action == 1) { 785 ret = iwl_mvm_int_mlo_scan(mvm, vif); 786 } else { 787 ret = -EINVAL; 788 } 789 790 mutex_unlock(&mvm->mutex); 791 792 return ret ?: count; 793 } 794 795 static ssize_t iwl_dbgfs_esr_disable_reason_read(struct file *file, 796 char __user *user_buf, 797 size_t count, loff_t *ppos) 798 { 799 struct ieee80211_vif *vif = file->private_data; 800 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 801 struct iwl_mvm *mvm = mvmvif->mvm; 802 unsigned long esr_mask; 803 char *buf; 804 int bufsz, pos, i; 805 ssize_t rv; 806 807 mutex_lock(&mvm->mutex); 808 esr_mask = mvmvif->esr_disable_reason; 809 mutex_unlock(&mvm->mutex); 810 811 bufsz = hweight32(esr_mask) * 32 + 40; 812 buf = kmalloc(bufsz, GFP_KERNEL); 813 if (!buf) 814 return -ENOMEM; 815 816 pos = scnprintf(buf, bufsz, "EMLSR state: '0x%lx'\nreasons:\n", 817 esr_mask); 818 for_each_set_bit(i, &esr_mask, BITS_PER_LONG) 819 pos += scnprintf(buf + pos, bufsz - pos, " - %s\n", 820 iwl_get_esr_state_string(BIT(i))); 821 822 rv = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 823 kfree(buf); 824 return rv; 825 } 826 827 static ssize_t iwl_dbgfs_esr_disable_reason_write(struct ieee80211_vif *vif, 828 char *buf, size_t count, 829 loff_t *ppos) 830 { 831 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 832 struct iwl_mvm *mvm = mvmvif->mvm; 833 u32 reason; 834 u8 block; 835 int ret; 836 837 ret = sscanf(buf, "%u %hhu", &reason, &block); 838 if (ret < 0) 839 return ret; 840 841 if (hweight16(reason) != 1 || !(reason & IWL_MVM_BLOCK_ESR_REASONS)) 842 return -EINVAL; 843 844 mutex_lock(&mvm->mutex); 845 if (block) 846 iwl_mvm_block_esr(mvm, vif, reason, 847 iwl_mvm_get_primary_link(vif)); 848 else 849 iwl_mvm_unblock_esr(mvm, vif, reason); 850 mutex_unlock(&mvm->mutex); 851 852 return count; 853 } 854 855 #define MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz) \ 856 _MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif) 857 #define MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \ 858 _MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif) 859 #define MVM_DEBUGFS_ADD_FILE_VIF(name, parent, mode) do { \ 860 debugfs_create_file(#name, mode, parent, vif, \ 861 &iwl_dbgfs_##name##_ops); \ 862 } while (0) 863 864 MVM_DEBUGFS_READ_FILE_OPS(mac_params); 865 MVM_DEBUGFS_READ_FILE_OPS(tx_pwr_lmt); 866 MVM_DEBUGFS_READ_WRITE_FILE_OPS(pm_params, 32); 867 MVM_DEBUGFS_READ_WRITE_FILE_OPS(bf_params, 256); 868 869 static const struct file_operations iwl_dbgfs_low_latency_ops = { 870 .write = iwl_dbgfs_low_latency_write, 871 .read = iwl_dbgfs_low_latency_read, 872 .open = simple_open, 873 .llseek = generic_file_llseek, 874 }; 875 876 static const struct file_operations iwl_dbgfs_low_latency_force_ops = { 877 .write = iwl_dbgfs_low_latency_force_write, 878 .open = simple_open, 879 .llseek = generic_file_llseek, 880 }; 881 882 MVM_DEBUGFS_READ_WRITE_FILE_OPS(uapsd_misbehaving, 20); 883 MVM_DEBUGFS_READ_WRITE_FILE_OPS(rx_phyinfo, 10); 884 MVM_DEBUGFS_READ_WRITE_FILE_OPS(quota_min, 32); 885 MVM_DEBUGFS_READ_FILE_OPS(os_device_timediff); 886 MVM_DEBUGFS_READ_WRITE_FILE_OPS(max_tx_op, 10); 887 MVM_DEBUGFS_WRITE_FILE_OPS(int_mlo_scan, 32); 888 MVM_DEBUGFS_READ_WRITE_FILE_OPS(esr_disable_reason, 32); 889 890 void iwl_mvm_vif_add_debugfs(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 891 { 892 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); 893 struct dentry *dbgfs_dir = vif->debugfs_dir; 894 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 895 896 mvmvif->dbgfs_dir = debugfs_create_dir("iwlmvm", dbgfs_dir); 897 if (IS_ERR_OR_NULL(mvmvif->dbgfs_dir)) { 898 IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n", 899 dbgfs_dir); 900 return; 901 } 902 903 if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM && 904 ((vif->type == NL80211_IFTYPE_STATION && !vif->p2p) || 905 (vif->type == NL80211_IFTYPE_STATION && vif->p2p))) 906 MVM_DEBUGFS_ADD_FILE_VIF(pm_params, mvmvif->dbgfs_dir, 0600); 907 908 MVM_DEBUGFS_ADD_FILE_VIF(tx_pwr_lmt, mvmvif->dbgfs_dir, 0400); 909 MVM_DEBUGFS_ADD_FILE_VIF(mac_params, mvmvif->dbgfs_dir, 0400); 910 MVM_DEBUGFS_ADD_FILE_VIF(low_latency, mvmvif->dbgfs_dir, 0600); 911 MVM_DEBUGFS_ADD_FILE_VIF(low_latency_force, mvmvif->dbgfs_dir, 0600); 912 MVM_DEBUGFS_ADD_FILE_VIF(uapsd_misbehaving, mvmvif->dbgfs_dir, 0600); 913 MVM_DEBUGFS_ADD_FILE_VIF(rx_phyinfo, mvmvif->dbgfs_dir, 0600); 914 MVM_DEBUGFS_ADD_FILE_VIF(quota_min, mvmvif->dbgfs_dir, 0600); 915 MVM_DEBUGFS_ADD_FILE_VIF(os_device_timediff, mvmvif->dbgfs_dir, 0400); 916 MVM_DEBUGFS_ADD_FILE_VIF(max_tx_op, mvmvif->dbgfs_dir, 0600); 917 debugfs_create_bool("ftm_unprotected", 0200, mvmvif->dbgfs_dir, 918 &mvmvif->ftm_unprotected); 919 MVM_DEBUGFS_ADD_FILE_VIF(int_mlo_scan, mvmvif->dbgfs_dir, 0200); 920 MVM_DEBUGFS_ADD_FILE_VIF(esr_disable_reason, mvmvif->dbgfs_dir, 0600); 921 922 if (vif->type == NL80211_IFTYPE_STATION && !vif->p2p && 923 mvmvif == mvm->bf_allowed_vif) 924 MVM_DEBUGFS_ADD_FILE_VIF(bf_params, mvmvif->dbgfs_dir, 0600); 925 } 926 927 void iwl_mvm_vif_dbgfs_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 928 { 929 struct dentry *dbgfs_dir = vif->debugfs_dir; 930 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 931 char buf[3 * 3 + 11 + (NL80211_WIPHY_NAME_MAXLEN + 1) + 932 (7 + IFNAMSIZ + 1) + 6 + 1]; 933 char name[7 + IFNAMSIZ + 1]; 934 935 /* this will happen in monitor mode */ 936 if (!dbgfs_dir) 937 return; 938 939 /* 940 * Create symlink for convenience pointing to interface specific 941 * debugfs entries for the driver. For example, under 942 * /sys/kernel/debug/iwlwifi/0000\:02\:00.0/iwlmvm/ 943 * find 944 * netdev:wlan0 -> ../../../ieee80211/phy0/netdev:wlan0/iwlmvm/ 945 */ 946 snprintf(name, sizeof(name), "%pd", dbgfs_dir); 947 snprintf(buf, sizeof(buf), "../../../%pd3/iwlmvm", dbgfs_dir); 948 949 mvmvif->dbgfs_slink = 950 debugfs_create_symlink(name, mvm->debugfs_dir, buf); 951 } 952 953 void iwl_mvm_vif_dbgfs_rm_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 954 { 955 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 956 957 debugfs_remove(mvmvif->dbgfs_slink); 958 mvmvif->dbgfs_slink = NULL; 959 } 960 961 #define MVM_DEBUGFS_WRITE_LINK_FILE_OPS(name, bufsz) \ 962 _MVM_DEBUGFS_WRITE_FILE_OPS(link_##name, bufsz, \ 963 struct ieee80211_bss_conf) 964 #define MVM_DEBUGFS_READ_WRITE_LINK_FILE_OPS(name, bufsz) \ 965 _MVM_DEBUGFS_READ_WRITE_FILE_OPS(link_##name, bufsz, \ 966 struct ieee80211_bss_conf) 967 #define MVM_DEBUGFS_ADD_LINK_FILE(name, parent, mode) \ 968 debugfs_create_file(#name, mode, parent, link_conf, \ 969 &iwl_dbgfs_link_##name##_ops) 970 971 static void iwl_mvm_debugfs_add_link_files(struct ieee80211_vif *vif, 972 struct ieee80211_bss_conf *link_conf, 973 struct dentry *mvm_dir) 974 { 975 /* Add per-link files here*/ 976 } 977 978 void iwl_mvm_link_add_debugfs(struct ieee80211_hw *hw, 979 struct ieee80211_vif *vif, 980 struct ieee80211_bss_conf *link_conf, 981 struct dentry *dir) 982 { 983 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 984 struct iwl_mvm *mvm = mvmvif->mvm; 985 unsigned int link_id = link_conf->link_id; 986 struct iwl_mvm_vif_link_info *link_info = mvmvif->link[link_id]; 987 struct dentry *mvm_dir; 988 989 if (WARN_ON(!link_info) || !dir) 990 return; 991 992 if (dir == vif->debugfs_dir) { 993 WARN_ON(!mvmvif->dbgfs_dir); 994 mvm_dir = mvmvif->dbgfs_dir; 995 } else { 996 mvm_dir = debugfs_create_dir("iwlmvm", dir); 997 if (IS_ERR_OR_NULL(mvm_dir)) { 998 IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n", 999 dir); 1000 return; 1001 } 1002 } 1003 1004 iwl_mvm_debugfs_add_link_files(vif, link_conf, mvm_dir); 1005 } 1006