| 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 |
#define MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz) \ |
| 766 |
_MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif) |
| 767 |
#define MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \ |
| 768 |
_MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif) |
| 769 |
#define MVM_DEBUGFS_ADD_FILE_VIF(name, parent, mode) do { \ |
| 770 |
debugfs_create_file(#name, mode, parent, vif, \ |
| 771 |
&iwl_dbgfs_##name##_ops); \ |
| 772 |
} while (0) |
| 773 |
|
| 774 |
MVM_DEBUGFS_READ_FILE_OPS(mac_params); |
| 775 |
MVM_DEBUGFS_READ_FILE_OPS(tx_pwr_lmt); |
| 776 |
MVM_DEBUGFS_READ_WRITE_FILE_OPS(pm_params, 32); |
| 777 |
MVM_DEBUGFS_READ_WRITE_FILE_OPS(bf_params, 256); |
| 778 |
|
| 779 |
static const struct file_operations iwl_dbgfs_low_latency_ops = { |
| 780 |
.write = iwl_dbgfs_low_latency_write, |
| 781 |
.read = iwl_dbgfs_low_latency_read, |
| 782 |
.open = simple_open, |
| 783 |
.llseek = generic_file_llseek, |
| 784 |
}; |
| 785 |
|
| 786 |
static const struct file_operations iwl_dbgfs_low_latency_force_ops = { |
| 787 |
.write = iwl_dbgfs_low_latency_force_write, |
| 788 |
.open = simple_open, |
| 789 |
.llseek = generic_file_llseek, |
| 790 |
}; |
| 791 |
|
| 792 |
MVM_DEBUGFS_READ_WRITE_FILE_OPS(uapsd_misbehaving, 20); |
| 793 |
MVM_DEBUGFS_READ_WRITE_FILE_OPS(rx_phyinfo, 10); |
| 794 |
MVM_DEBUGFS_READ_WRITE_FILE_OPS(quota_min, 32); |
| 795 |
MVM_DEBUGFS_READ_FILE_OPS(os_device_timediff); |
| 796 |
MVM_DEBUGFS_READ_WRITE_FILE_OPS(max_tx_op, 10); |
| 797 |
|
| 798 |
void iwl_mvm_vif_add_debugfs(struct ieee80211_hw *hw, struct ieee80211_vif *vif) |
| 799 |
{ |
| 800 |
struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw); |
| 801 |
struct dentry *dbgfs_dir = vif->debugfs_dir; |
| 802 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 803 |
|
| 804 |
mvmvif->dbgfs_dir = debugfs_create_dir("iwlmvm", dbgfs_dir); |
| 805 |
if (IS_ERR_OR_NULL(mvmvif->dbgfs_dir)) { |
| 806 |
IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n", |
| 807 |
dbgfs_dir); |
| 808 |
return; |
| 809 |
} |
| 810 |
|
| 811 |
if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM && |
| 812 |
((vif->type == NL80211_IFTYPE_STATION && !vif->p2p) || |
| 813 |
(vif->type == NL80211_IFTYPE_STATION && vif->p2p))) |
| 814 |
MVM_DEBUGFS_ADD_FILE_VIF(pm_params, mvmvif->dbgfs_dir, 0600); |
| 815 |
|
| 816 |
MVM_DEBUGFS_ADD_FILE_VIF(tx_pwr_lmt, mvmvif->dbgfs_dir, 0400); |
| 817 |
MVM_DEBUGFS_ADD_FILE_VIF(mac_params, mvmvif->dbgfs_dir, 0400); |
| 818 |
MVM_DEBUGFS_ADD_FILE_VIF(low_latency, mvmvif->dbgfs_dir, 0600); |
| 819 |
MVM_DEBUGFS_ADD_FILE_VIF(low_latency_force, mvmvif->dbgfs_dir, 0600); |
| 820 |
MVM_DEBUGFS_ADD_FILE_VIF(uapsd_misbehaving, mvmvif->dbgfs_dir, 0600); |
| 821 |
MVM_DEBUGFS_ADD_FILE_VIF(rx_phyinfo, mvmvif->dbgfs_dir, 0600); |
| 822 |
MVM_DEBUGFS_ADD_FILE_VIF(quota_min, mvmvif->dbgfs_dir, 0600); |
| 823 |
MVM_DEBUGFS_ADD_FILE_VIF(os_device_timediff, mvmvif->dbgfs_dir, 0400); |
| 824 |
MVM_DEBUGFS_ADD_FILE_VIF(max_tx_op, mvmvif->dbgfs_dir, 0600); |
| 825 |
debugfs_create_bool("ftm_unprotected", 0200, mvmvif->dbgfs_dir, |
| 826 |
&mvmvif->ftm_unprotected); |
| 827 |
|
| 828 |
if (vif->type == NL80211_IFTYPE_STATION && !vif->p2p && |
| 829 |
mvmvif == mvm->bf_allowed_vif) |
| 830 |
MVM_DEBUGFS_ADD_FILE_VIF(bf_params, mvmvif->dbgfs_dir, 0600); |
| 831 |
} |
| 832 |
|
| 833 |
void iwl_mvm_vif_dbgfs_add_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif) |
| 834 |
{ |
| 835 |
struct dentry *dbgfs_dir = vif->debugfs_dir; |
| 836 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 837 |
char buf[3 * 3 + 11 + (NL80211_WIPHY_NAME_MAXLEN + 1) + |
| 838 |
(7 + IFNAMSIZ + 1) + 6 + 1]; |
| 839 |
char name[7 + IFNAMSIZ + 1]; |
| 840 |
|
| 841 |
/* this will happen in monitor mode */ |
| 842 |
if (!dbgfs_dir) |
| 843 |
return; |
| 844 |
|
| 845 |
/* |
| 846 |
* Create symlink for convenience pointing to interface specific |
| 847 |
* debugfs entries for the driver. For example, under |
| 848 |
* /sys/kernel/debug/iwlwifi/0000\:02\:00.0/iwlmvm/ |
| 849 |
* find |
| 850 |
* netdev:wlan0 -> ../../../ieee80211/phy0/netdev:wlan0/iwlmvm/ |
| 851 |
*/ |
| 852 |
snprintf(name, sizeof(name), "%pd", dbgfs_dir); |
| 853 |
snprintf(buf, sizeof(buf), "../../../%pd3/iwlmvm", dbgfs_dir); |
| 854 |
|
| 855 |
mvmvif->dbgfs_slink = |
| 856 |
debugfs_create_symlink(name, mvm->debugfs_dir, buf); |
| 857 |
} |
| 858 |
|
| 859 |
void iwl_mvm_vif_dbgfs_rm_link(struct iwl_mvm *mvm, struct ieee80211_vif *vif) |
| 860 |
{ |
| 861 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 862 |
|
| 863 |
debugfs_remove(mvmvif->dbgfs_slink); |
| 864 |
mvmvif->dbgfs_slink = NULL; |
| 865 |
} |
| 866 |
|
| 867 |
#define MVM_DEBUGFS_WRITE_LINK_FILE_OPS(name, bufsz) \ |
| 868 |
_MVM_DEBUGFS_WRITE_FILE_OPS(link_##name, bufsz, \ |
| 869 |
struct ieee80211_bss_conf) |
| 870 |
#define MVM_DEBUGFS_READ_WRITE_LINK_FILE_OPS(name, bufsz) \ |
| 871 |
_MVM_DEBUGFS_READ_WRITE_FILE_OPS(link_##name, bufsz, \ |
| 872 |
struct ieee80211_bss_conf) |
| 873 |
#define MVM_DEBUGFS_ADD_LINK_FILE(name, parent, mode) \ |
| 874 |
debugfs_create_file(#name, mode, parent, link_conf, \ |
| 875 |
&iwl_dbgfs_link_##name##_ops) |
| 876 |
|
| 877 |
static void iwl_mvm_debugfs_add_link_files(struct ieee80211_vif *vif, |
| 878 |
struct ieee80211_bss_conf *link_conf, |
| 879 |
struct dentry *mvm_dir) |
| 880 |
{ |
| 881 |
/* Add per-link files here*/ |
| 882 |
} |
| 883 |
|
| 884 |
void iwl_mvm_link_add_debugfs(struct ieee80211_hw *hw, |
| 885 |
struct ieee80211_vif *vif, |
| 886 |
struct ieee80211_bss_conf *link_conf, |
| 887 |
struct dentry *dir) |
| 888 |
{ |
| 889 |
struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| 890 |
struct iwl_mvm *mvm = mvmvif->mvm; |
| 891 |
unsigned int link_id = link_conf->link_id; |
| 892 |
struct iwl_mvm_vif_link_info *link_info = mvmvif->link[link_id]; |
| 893 |
struct dentry *mvm_dir; |
| 894 |
|
| 895 |
if (WARN_ON(!link_info) || !dir) |
| 896 |
return; |
| 897 |
|
| 898 |
if (dir == vif->debugfs_dir) { |
| 899 |
WARN_ON(!mvmvif->dbgfs_dir); |
| 900 |
mvm_dir = mvmvif->dbgfs_dir; |
| 901 |
} else { |
| 902 |
mvm_dir = debugfs_create_dir("iwlmvm", dir); |
| 903 |
if (IS_ERR_OR_NULL(mvm_dir)) { |
| 904 |
IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n", |
| 905 |
dir); |
| 906 |
return; |
| 907 |
} |
| 908 |
} |
| 909 |
|
| 910 |
iwl_mvm_debugfs_add_link_files(vif, link_conf, mvm_dir); |
| 911 |
} |