Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
0002 /*
0003  * Copyright (C) 2012-2014, 2018-2021 Intel Corporation
0004  * Copyright (C) 2013-2015 Intel Mobile Communications GmbH
0005  * Copyright (C) 2016-2017 Intel Deutschland GmbH
0006  */
0007 #include "mvm.h"
0008 #include "debugfs.h"
0009 
0010 static void iwl_dbgfs_update_pm(struct iwl_mvm *mvm,
0011                  struct ieee80211_vif *vif,
0012                  enum iwl_dbgfs_pm_mask param, int val)
0013 {
0014     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0015     struct iwl_dbgfs_pm *dbgfs_pm = &mvmvif->dbgfs_pm;
0016 
0017     dbgfs_pm->mask |= param;
0018 
0019     switch (param) {
0020     case MVM_DEBUGFS_PM_KEEP_ALIVE: {
0021         int dtimper = vif->bss_conf.dtim_period ?: 1;
0022         int dtimper_msec = dtimper * vif->bss_conf.beacon_int;
0023 
0024         IWL_DEBUG_POWER(mvm, "debugfs: set keep_alive= %d sec\n", val);
0025         if (val * MSEC_PER_SEC < 3 * dtimper_msec)
0026             IWL_WARN(mvm,
0027                  "debugfs: keep alive period (%ld msec) is less than minimum required (%d msec)\n",
0028                  val * MSEC_PER_SEC, 3 * dtimper_msec);
0029         dbgfs_pm->keep_alive_seconds = val;
0030         break;
0031     }
0032     case MVM_DEBUGFS_PM_SKIP_OVER_DTIM:
0033         IWL_DEBUG_POWER(mvm, "skip_over_dtim %s\n",
0034                 val ? "enabled" : "disabled");
0035         dbgfs_pm->skip_over_dtim = val;
0036         break;
0037     case MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS:
0038         IWL_DEBUG_POWER(mvm, "skip_dtim_periods=%d\n", val);
0039         dbgfs_pm->skip_dtim_periods = val;
0040         break;
0041     case MVM_DEBUGFS_PM_RX_DATA_TIMEOUT:
0042         IWL_DEBUG_POWER(mvm, "rx_data_timeout=%d\n", val);
0043         dbgfs_pm->rx_data_timeout = val;
0044         break;
0045     case MVM_DEBUGFS_PM_TX_DATA_TIMEOUT:
0046         IWL_DEBUG_POWER(mvm, "tx_data_timeout=%d\n", val);
0047         dbgfs_pm->tx_data_timeout = val;
0048         break;
0049     case MVM_DEBUGFS_PM_LPRX_ENA:
0050         IWL_DEBUG_POWER(mvm, "lprx %s\n", val ? "enabled" : "disabled");
0051         dbgfs_pm->lprx_ena = val;
0052         break;
0053     case MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD:
0054         IWL_DEBUG_POWER(mvm, "lprx_rssi_threshold=%d\n", val);
0055         dbgfs_pm->lprx_rssi_threshold = val;
0056         break;
0057     case MVM_DEBUGFS_PM_SNOOZE_ENABLE:
0058         IWL_DEBUG_POWER(mvm, "snooze_enable=%d\n", val);
0059         dbgfs_pm->snooze_ena = val;
0060         break;
0061     case MVM_DEBUGFS_PM_UAPSD_MISBEHAVING:
0062         IWL_DEBUG_POWER(mvm, "uapsd_misbehaving_enable=%d\n", val);
0063         dbgfs_pm->uapsd_misbehaving = val;
0064         break;
0065     case MVM_DEBUGFS_PM_USE_PS_POLL:
0066         IWL_DEBUG_POWER(mvm, "use_ps_poll=%d\n", val);
0067         dbgfs_pm->use_ps_poll = val;
0068         break;
0069     }
0070 }
0071 
0072 static ssize_t iwl_dbgfs_pm_params_write(struct ieee80211_vif *vif, char *buf,
0073                      size_t count, loff_t *ppos)
0074 {
0075     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0076     struct iwl_mvm *mvm = mvmvif->mvm;
0077     enum iwl_dbgfs_pm_mask param;
0078     int val, ret;
0079 
0080     if (!strncmp("keep_alive=", buf, 11)) {
0081         if (sscanf(buf + 11, "%d", &val) != 1)
0082             return -EINVAL;
0083         param = MVM_DEBUGFS_PM_KEEP_ALIVE;
0084     } else if (!strncmp("skip_over_dtim=", buf, 15)) {
0085         if (sscanf(buf + 15, "%d", &val) != 1)
0086             return -EINVAL;
0087         param = MVM_DEBUGFS_PM_SKIP_OVER_DTIM;
0088     } else if (!strncmp("skip_dtim_periods=", buf, 18)) {
0089         if (sscanf(buf + 18, "%d", &val) != 1)
0090             return -EINVAL;
0091         param = MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS;
0092     } else if (!strncmp("rx_data_timeout=", buf, 16)) {
0093         if (sscanf(buf + 16, "%d", &val) != 1)
0094             return -EINVAL;
0095         param = MVM_DEBUGFS_PM_RX_DATA_TIMEOUT;
0096     } else if (!strncmp("tx_data_timeout=", buf, 16)) {
0097         if (sscanf(buf + 16, "%d", &val) != 1)
0098             return -EINVAL;
0099         param = MVM_DEBUGFS_PM_TX_DATA_TIMEOUT;
0100     } else if (!strncmp("lprx=", buf, 5)) {
0101         if (sscanf(buf + 5, "%d", &val) != 1)
0102             return -EINVAL;
0103         param = MVM_DEBUGFS_PM_LPRX_ENA;
0104     } else if (!strncmp("lprx_rssi_threshold=", buf, 20)) {
0105         if (sscanf(buf + 20, "%d", &val) != 1)
0106             return -EINVAL;
0107         if (val > POWER_LPRX_RSSI_THRESHOLD_MAX || val <
0108             POWER_LPRX_RSSI_THRESHOLD_MIN)
0109             return -EINVAL;
0110         param = MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD;
0111     } else if (!strncmp("snooze_enable=", buf, 14)) {
0112         if (sscanf(buf + 14, "%d", &val) != 1)
0113             return -EINVAL;
0114         param = MVM_DEBUGFS_PM_SNOOZE_ENABLE;
0115     } else if (!strncmp("uapsd_misbehaving=", buf, 18)) {
0116         if (sscanf(buf + 18, "%d", &val) != 1)
0117             return -EINVAL;
0118         param = MVM_DEBUGFS_PM_UAPSD_MISBEHAVING;
0119     } else if (!strncmp("use_ps_poll=", buf, 12)) {
0120         if (sscanf(buf + 12, "%d", &val) != 1)
0121             return -EINVAL;
0122         param = MVM_DEBUGFS_PM_USE_PS_POLL;
0123     } else {
0124         return -EINVAL;
0125     }
0126 
0127     mutex_lock(&mvm->mutex);
0128     iwl_dbgfs_update_pm(mvm, vif, param, val);
0129     ret = iwl_mvm_power_update_mac(mvm);
0130     mutex_unlock(&mvm->mutex);
0131 
0132     return ret ?: count;
0133 }
0134 
0135 static ssize_t iwl_dbgfs_tx_pwr_lmt_read(struct file *file,
0136                      char __user *user_buf,
0137                      size_t count, loff_t *ppos)
0138 {
0139     struct ieee80211_vif *vif = file->private_data;
0140     char buf[64];
0141     int bufsz = sizeof(buf);
0142     int pos;
0143 
0144     pos = scnprintf(buf, bufsz, "bss limit = %d\n",
0145             vif->bss_conf.txpower);
0146 
0147     return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
0148 }
0149 
0150 static ssize_t iwl_dbgfs_pm_params_read(struct file *file,
0151                     char __user *user_buf,
0152                     size_t count, loff_t *ppos)
0153 {
0154     struct ieee80211_vif *vif = file->private_data;
0155     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0156     struct iwl_mvm *mvm = mvmvif->mvm;
0157     char buf[512];
0158     int bufsz = sizeof(buf);
0159     int pos;
0160 
0161     pos = iwl_mvm_power_mac_dbgfs_read(mvm, vif, buf, bufsz);
0162 
0163     return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
0164 }
0165 
0166 static ssize_t iwl_dbgfs_mac_params_read(struct file *file,
0167                      char __user *user_buf,
0168                      size_t count, loff_t *ppos)
0169 {
0170     struct ieee80211_vif *vif = file->private_data;
0171     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0172     struct iwl_mvm *mvm = mvmvif->mvm;
0173     u8 ap_sta_id;
0174     struct ieee80211_chanctx_conf *chanctx_conf;
0175     char buf[512];
0176     int bufsz = sizeof(buf);
0177     int pos = 0;
0178     int i;
0179 
0180     mutex_lock(&mvm->mutex);
0181 
0182     ap_sta_id = mvmvif->ap_sta_id;
0183 
0184     switch (ieee80211_vif_type_p2p(vif)) {
0185     case NL80211_IFTYPE_ADHOC:
0186         pos += scnprintf(buf+pos, bufsz-pos, "type: ibss\n");
0187         break;
0188     case NL80211_IFTYPE_STATION:
0189         pos += scnprintf(buf+pos, bufsz-pos, "type: bss\n");
0190         break;
0191     case NL80211_IFTYPE_AP:
0192         pos += scnprintf(buf+pos, bufsz-pos, "type: ap\n");
0193         break;
0194     case NL80211_IFTYPE_P2P_CLIENT:
0195         pos += scnprintf(buf+pos, bufsz-pos, "type: p2p client\n");
0196         break;
0197     case NL80211_IFTYPE_P2P_GO:
0198         pos += scnprintf(buf+pos, bufsz-pos, "type: p2p go\n");
0199         break;
0200     case NL80211_IFTYPE_P2P_DEVICE:
0201         pos += scnprintf(buf+pos, bufsz-pos, "type: p2p dev\n");
0202         break;
0203     default:
0204         break;
0205     }
0206 
0207     pos += scnprintf(buf+pos, bufsz-pos, "mac id/color: %d / %d\n",
0208              mvmvif->id, mvmvif->color);
0209     pos += scnprintf(buf+pos, bufsz-pos, "bssid: %pM\n",
0210              vif->bss_conf.bssid);
0211     pos += scnprintf(buf+pos, bufsz-pos, "Load: %d\n",
0212              mvm->tcm.result.load[mvmvif->id]);
0213     pos += scnprintf(buf+pos, bufsz-pos, "QoS:\n");
0214     for (i = 0; i < ARRAY_SIZE(mvmvif->queue_params); i++)
0215         pos += scnprintf(buf+pos, bufsz-pos,
0216                  "\t%d: txop:%d - cw_min:%d - cw_max = %d - aifs = %d upasd = %d\n",
0217                  i, mvmvif->queue_params[i].txop,
0218                  mvmvif->queue_params[i].cw_min,
0219                  mvmvif->queue_params[i].cw_max,
0220                  mvmvif->queue_params[i].aifs,
0221                  mvmvif->queue_params[i].uapsd);
0222 
0223     if (vif->type == NL80211_IFTYPE_STATION &&
0224         ap_sta_id != IWL_MVM_INVALID_STA) {
0225         struct iwl_mvm_sta *mvm_sta;
0226 
0227         mvm_sta = iwl_mvm_sta_from_staid_protected(mvm, ap_sta_id);
0228         if (mvm_sta) {
0229             pos += scnprintf(buf+pos, bufsz-pos,
0230                      "ap_sta_id %d - reduced Tx power %d\n",
0231                      ap_sta_id,
0232                      mvm_sta->bt_reduced_txpower);
0233         }
0234     }
0235 
0236     rcu_read_lock();
0237     chanctx_conf = rcu_dereference(vif->bss_conf.chanctx_conf);
0238     if (chanctx_conf)
0239         pos += scnprintf(buf+pos, bufsz-pos,
0240                  "idle rx chains %d, active rx chains: %d\n",
0241                  chanctx_conf->rx_chains_static,
0242                  chanctx_conf->rx_chains_dynamic);
0243     rcu_read_unlock();
0244 
0245     mutex_unlock(&mvm->mutex);
0246 
0247     return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
0248 }
0249 
0250 static void iwl_dbgfs_update_bf(struct ieee80211_vif *vif,
0251                 enum iwl_dbgfs_bf_mask param, int value)
0252 {
0253     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0254     struct iwl_dbgfs_bf *dbgfs_bf = &mvmvif->dbgfs_bf;
0255 
0256     dbgfs_bf->mask |= param;
0257 
0258     switch (param) {
0259     case MVM_DEBUGFS_BF_ENERGY_DELTA:
0260         dbgfs_bf->bf_energy_delta = value;
0261         break;
0262     case MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA:
0263         dbgfs_bf->bf_roaming_energy_delta = value;
0264         break;
0265     case MVM_DEBUGFS_BF_ROAMING_STATE:
0266         dbgfs_bf->bf_roaming_state = value;
0267         break;
0268     case MVM_DEBUGFS_BF_TEMP_THRESHOLD:
0269         dbgfs_bf->bf_temp_threshold = value;
0270         break;
0271     case MVM_DEBUGFS_BF_TEMP_FAST_FILTER:
0272         dbgfs_bf->bf_temp_fast_filter = value;
0273         break;
0274     case MVM_DEBUGFS_BF_TEMP_SLOW_FILTER:
0275         dbgfs_bf->bf_temp_slow_filter = value;
0276         break;
0277     case MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER:
0278         dbgfs_bf->bf_enable_beacon_filter = value;
0279         break;
0280     case MVM_DEBUGFS_BF_DEBUG_FLAG:
0281         dbgfs_bf->bf_debug_flag = value;
0282         break;
0283     case MVM_DEBUGFS_BF_ESCAPE_TIMER:
0284         dbgfs_bf->bf_escape_timer = value;
0285         break;
0286     case MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT:
0287         dbgfs_bf->ba_enable_beacon_abort = value;
0288         break;
0289     case MVM_DEBUGFS_BA_ESCAPE_TIMER:
0290         dbgfs_bf->ba_escape_timer = value;
0291         break;
0292     }
0293 }
0294 
0295 static ssize_t iwl_dbgfs_bf_params_write(struct ieee80211_vif *vif, char *buf,
0296                      size_t count, loff_t *ppos)
0297 {
0298     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0299     struct iwl_mvm *mvm = mvmvif->mvm;
0300     enum iwl_dbgfs_bf_mask param;
0301     int value, ret = 0;
0302 
0303     if (!strncmp("bf_energy_delta=", buf, 16)) {
0304         if (sscanf(buf+16, "%d", &value) != 1)
0305             return -EINVAL;
0306         if (value < IWL_BF_ENERGY_DELTA_MIN ||
0307             value > IWL_BF_ENERGY_DELTA_MAX)
0308             return -EINVAL;
0309         param = MVM_DEBUGFS_BF_ENERGY_DELTA;
0310     } else if (!strncmp("bf_roaming_energy_delta=", buf, 24)) {
0311         if (sscanf(buf+24, "%d", &value) != 1)
0312             return -EINVAL;
0313         if (value < IWL_BF_ROAMING_ENERGY_DELTA_MIN ||
0314             value > IWL_BF_ROAMING_ENERGY_DELTA_MAX)
0315             return -EINVAL;
0316         param = MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA;
0317     } else if (!strncmp("bf_roaming_state=", buf, 17)) {
0318         if (sscanf(buf+17, "%d", &value) != 1)
0319             return -EINVAL;
0320         if (value < IWL_BF_ROAMING_STATE_MIN ||
0321             value > IWL_BF_ROAMING_STATE_MAX)
0322             return -EINVAL;
0323         param = MVM_DEBUGFS_BF_ROAMING_STATE;
0324     } else if (!strncmp("bf_temp_threshold=", buf, 18)) {
0325         if (sscanf(buf+18, "%d", &value) != 1)
0326             return -EINVAL;
0327         if (value < IWL_BF_TEMP_THRESHOLD_MIN ||
0328             value > IWL_BF_TEMP_THRESHOLD_MAX)
0329             return -EINVAL;
0330         param = MVM_DEBUGFS_BF_TEMP_THRESHOLD;
0331     } else if (!strncmp("bf_temp_fast_filter=", buf, 20)) {
0332         if (sscanf(buf+20, "%d", &value) != 1)
0333             return -EINVAL;
0334         if (value < IWL_BF_TEMP_FAST_FILTER_MIN ||
0335             value > IWL_BF_TEMP_FAST_FILTER_MAX)
0336             return -EINVAL;
0337         param = MVM_DEBUGFS_BF_TEMP_FAST_FILTER;
0338     } else if (!strncmp("bf_temp_slow_filter=", buf, 20)) {
0339         if (sscanf(buf+20, "%d", &value) != 1)
0340             return -EINVAL;
0341         if (value < IWL_BF_TEMP_SLOW_FILTER_MIN ||
0342             value > IWL_BF_TEMP_SLOW_FILTER_MAX)
0343             return -EINVAL;
0344         param = MVM_DEBUGFS_BF_TEMP_SLOW_FILTER;
0345     } else if (!strncmp("bf_enable_beacon_filter=", buf, 24)) {
0346         if (sscanf(buf+24, "%d", &value) != 1)
0347             return -EINVAL;
0348         if (value < 0 || value > 1)
0349             return -EINVAL;
0350         param = MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER;
0351     } else if (!strncmp("bf_debug_flag=", buf, 14)) {
0352         if (sscanf(buf+14, "%d", &value) != 1)
0353             return -EINVAL;
0354         if (value < 0 || value > 1)
0355             return -EINVAL;
0356         param = MVM_DEBUGFS_BF_DEBUG_FLAG;
0357     } else if (!strncmp("bf_escape_timer=", buf, 16)) {
0358         if (sscanf(buf+16, "%d", &value) != 1)
0359             return -EINVAL;
0360         if (value < IWL_BF_ESCAPE_TIMER_MIN ||
0361             value > IWL_BF_ESCAPE_TIMER_MAX)
0362             return -EINVAL;
0363         param = MVM_DEBUGFS_BF_ESCAPE_TIMER;
0364     } else if (!strncmp("ba_escape_timer=", buf, 16)) {
0365         if (sscanf(buf+16, "%d", &value) != 1)
0366             return -EINVAL;
0367         if (value < IWL_BA_ESCAPE_TIMER_MIN ||
0368             value > IWL_BA_ESCAPE_TIMER_MAX)
0369             return -EINVAL;
0370         param = MVM_DEBUGFS_BA_ESCAPE_TIMER;
0371     } else if (!strncmp("ba_enable_beacon_abort=", buf, 23)) {
0372         if (sscanf(buf+23, "%d", &value) != 1)
0373             return -EINVAL;
0374         if (value < 0 || value > 1)
0375             return -EINVAL;
0376         param = MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT;
0377     } else {
0378         return -EINVAL;
0379     }
0380 
0381     mutex_lock(&mvm->mutex);
0382     iwl_dbgfs_update_bf(vif, param, value);
0383     if (param == MVM_DEBUGFS_BF_ENABLE_BEACON_FILTER && !value)
0384         ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
0385     else
0386         ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
0387     mutex_unlock(&mvm->mutex);
0388 
0389     return ret ?: count;
0390 }
0391 
0392 static ssize_t iwl_dbgfs_bf_params_read(struct file *file,
0393                     char __user *user_buf,
0394                     size_t count, loff_t *ppos)
0395 {
0396     struct ieee80211_vif *vif = file->private_data;
0397     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0398     char buf[256];
0399     int pos = 0;
0400     const size_t bufsz = sizeof(buf);
0401     struct iwl_beacon_filter_cmd cmd = {
0402         IWL_BF_CMD_CONFIG_DEFAULTS,
0403         .bf_enable_beacon_filter =
0404             cpu_to_le32(IWL_BF_ENABLE_BEACON_FILTER_DEFAULT),
0405         .ba_enable_beacon_abort =
0406             cpu_to_le32(IWL_BA_ENABLE_BEACON_ABORT_DEFAULT),
0407     };
0408 
0409     iwl_mvm_beacon_filter_debugfs_parameters(vif, &cmd);
0410     if (mvmvif->bf_data.bf_enabled)
0411         cmd.bf_enable_beacon_filter = cpu_to_le32(1);
0412     else
0413         cmd.bf_enable_beacon_filter = 0;
0414 
0415     pos += scnprintf(buf+pos, bufsz-pos, "bf_energy_delta = %d\n",
0416              le32_to_cpu(cmd.bf_energy_delta));
0417     pos += scnprintf(buf+pos, bufsz-pos, "bf_roaming_energy_delta = %d\n",
0418              le32_to_cpu(cmd.bf_roaming_energy_delta));
0419     pos += scnprintf(buf+pos, bufsz-pos, "bf_roaming_state = %d\n",
0420              le32_to_cpu(cmd.bf_roaming_state));
0421     pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_threshold = %d\n",
0422              le32_to_cpu(cmd.bf_temp_threshold));
0423     pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_fast_filter = %d\n",
0424              le32_to_cpu(cmd.bf_temp_fast_filter));
0425     pos += scnprintf(buf+pos, bufsz-pos, "bf_temp_slow_filter = %d\n",
0426              le32_to_cpu(cmd.bf_temp_slow_filter));
0427     pos += scnprintf(buf+pos, bufsz-pos, "bf_enable_beacon_filter = %d\n",
0428              le32_to_cpu(cmd.bf_enable_beacon_filter));
0429     pos += scnprintf(buf+pos, bufsz-pos, "bf_debug_flag = %d\n",
0430              le32_to_cpu(cmd.bf_debug_flag));
0431     pos += scnprintf(buf+pos, bufsz-pos, "bf_escape_timer = %d\n",
0432              le32_to_cpu(cmd.bf_escape_timer));
0433     pos += scnprintf(buf+pos, bufsz-pos, "ba_escape_timer = %d\n",
0434              le32_to_cpu(cmd.ba_escape_timer));
0435     pos += scnprintf(buf+pos, bufsz-pos, "ba_enable_beacon_abort = %d\n",
0436              le32_to_cpu(cmd.ba_enable_beacon_abort));
0437 
0438     return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
0439 }
0440 
0441 static inline char *iwl_dbgfs_is_match(char *name, char *buf)
0442 {
0443     int len = strlen(name);
0444 
0445     return !strncmp(name, buf, len) ? buf + len : NULL;
0446 }
0447 
0448 static ssize_t iwl_dbgfs_os_device_timediff_read(struct file *file,
0449                          char __user *user_buf,
0450                          size_t count, loff_t *ppos)
0451 {
0452     struct ieee80211_vif *vif = file->private_data;
0453     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0454     struct iwl_mvm *mvm = mvmvif->mvm;
0455     u32 curr_gp2;
0456     u64 curr_os;
0457     s64 diff;
0458     char buf[64];
0459     const size_t bufsz = sizeof(buf);
0460     int pos = 0;
0461 
0462     mutex_lock(&mvm->mutex);
0463     iwl_mvm_get_sync_time(mvm, CLOCK_BOOTTIME, &curr_gp2, &curr_os, NULL);
0464     mutex_unlock(&mvm->mutex);
0465 
0466     do_div(curr_os, NSEC_PER_USEC);
0467     diff = curr_os - curr_gp2;
0468     pos += scnprintf(buf + pos, bufsz - pos, "diff=%lld\n", diff);
0469 
0470     return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
0471 }
0472 
0473 static ssize_t iwl_dbgfs_low_latency_write(struct ieee80211_vif *vif, char *buf,
0474                        size_t count, loff_t *ppos)
0475 {
0476     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0477     struct iwl_mvm *mvm = mvmvif->mvm;
0478     u8 value;
0479     int ret;
0480 
0481     ret = kstrtou8(buf, 0, &value);
0482     if (ret)
0483         return ret;
0484     if (value > 1)
0485         return -EINVAL;
0486 
0487     mutex_lock(&mvm->mutex);
0488     iwl_mvm_update_low_latency(mvm, vif, value, LOW_LATENCY_DEBUGFS);
0489     mutex_unlock(&mvm->mutex);
0490 
0491     return count;
0492 }
0493 
0494 static ssize_t
0495 iwl_dbgfs_low_latency_force_write(struct ieee80211_vif *vif, char *buf,
0496                   size_t count, loff_t *ppos)
0497 {
0498     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0499     struct iwl_mvm *mvm = mvmvif->mvm;
0500     u8 value;
0501     int ret;
0502 
0503     ret = kstrtou8(buf, 0, &value);
0504     if (ret)
0505         return ret;
0506 
0507     if (value > NUM_LOW_LATENCY_FORCE)
0508         return -EINVAL;
0509 
0510     mutex_lock(&mvm->mutex);
0511     if (value == LOW_LATENCY_FORCE_UNSET) {
0512         iwl_mvm_update_low_latency(mvm, vif, false,
0513                        LOW_LATENCY_DEBUGFS_FORCE);
0514         iwl_mvm_update_low_latency(mvm, vif, false,
0515                        LOW_LATENCY_DEBUGFS_FORCE_ENABLE);
0516     } else {
0517         iwl_mvm_update_low_latency(mvm, vif,
0518                        value == LOW_LATENCY_FORCE_ON,
0519                        LOW_LATENCY_DEBUGFS_FORCE);
0520         iwl_mvm_update_low_latency(mvm, vif, true,
0521                        LOW_LATENCY_DEBUGFS_FORCE_ENABLE);
0522     }
0523     mutex_unlock(&mvm->mutex);
0524     return count;
0525 }
0526 
0527 static ssize_t iwl_dbgfs_low_latency_read(struct file *file,
0528                       char __user *user_buf,
0529                       size_t count, loff_t *ppos)
0530 {
0531     struct ieee80211_vif *vif = file->private_data;
0532     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0533     char format[] = "traffic=%d\ndbgfs=%d\nvcmd=%d\nvif_type=%d\n"
0534             "dbgfs_force_enable=%d\ndbgfs_force=%d\nactual=%d\n";
0535 
0536     /*
0537      * all values in format are boolean so the size of format is enough
0538      * for holding the result string
0539      */
0540     char buf[sizeof(format) + 1] = {};
0541     int len;
0542 
0543     len = scnprintf(buf, sizeof(buf) - 1, format,
0544             !!(mvmvif->low_latency & LOW_LATENCY_TRAFFIC),
0545             !!(mvmvif->low_latency & LOW_LATENCY_DEBUGFS),
0546             !!(mvmvif->low_latency & LOW_LATENCY_VCMD),
0547             !!(mvmvif->low_latency & LOW_LATENCY_VIF_TYPE),
0548             !!(mvmvif->low_latency &
0549                LOW_LATENCY_DEBUGFS_FORCE_ENABLE),
0550             !!(mvmvif->low_latency & LOW_LATENCY_DEBUGFS_FORCE),
0551             !!(mvmvif->low_latency_actual));
0552     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0553 }
0554 
0555 static ssize_t iwl_dbgfs_uapsd_misbehaving_read(struct file *file,
0556                         char __user *user_buf,
0557                         size_t count, loff_t *ppos)
0558 {
0559     struct ieee80211_vif *vif = file->private_data;
0560     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0561     char buf[20];
0562     int len;
0563 
0564     len = sprintf(buf, "%pM\n", mvmvif->uapsd_misbehaving_bssid);
0565     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0566 }
0567 
0568 static ssize_t iwl_dbgfs_uapsd_misbehaving_write(struct ieee80211_vif *vif,
0569                          char *buf, size_t count,
0570                          loff_t *ppos)
0571 {
0572     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0573     struct iwl_mvm *mvm = mvmvif->mvm;
0574     bool ret;
0575 
0576     mutex_lock(&mvm->mutex);
0577     ret = mac_pton(buf, mvmvif->uapsd_misbehaving_bssid);
0578     mutex_unlock(&mvm->mutex);
0579 
0580     return ret ? count : -EINVAL;
0581 }
0582 
0583 static ssize_t iwl_dbgfs_rx_phyinfo_write(struct ieee80211_vif *vif, char *buf,
0584                       size_t count, loff_t *ppos)
0585 {
0586     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0587     struct iwl_mvm *mvm = mvmvif->mvm;
0588     struct ieee80211_chanctx_conf *chanctx_conf;
0589     struct iwl_mvm_phy_ctxt *phy_ctxt;
0590     u16 value;
0591     int ret;
0592 
0593     ret = kstrtou16(buf, 0, &value);
0594     if (ret)
0595         return ret;
0596 
0597     mutex_lock(&mvm->mutex);
0598     rcu_read_lock();
0599 
0600     chanctx_conf = rcu_dereference(vif->bss_conf.chanctx_conf);
0601     /* make sure the channel context is assigned */
0602     if (!chanctx_conf) {
0603         rcu_read_unlock();
0604         mutex_unlock(&mvm->mutex);
0605         return -EINVAL;
0606     }
0607 
0608     phy_ctxt = &mvm->phy_ctxts[*(u16 *)chanctx_conf->drv_priv];
0609     rcu_read_unlock();
0610 
0611     mvm->dbgfs_rx_phyinfo = value;
0612 
0613     ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &chanctx_conf->min_def,
0614                        chanctx_conf->rx_chains_static,
0615                        chanctx_conf->rx_chains_dynamic);
0616     mutex_unlock(&mvm->mutex);
0617 
0618     return ret ?: count;
0619 }
0620 
0621 static ssize_t iwl_dbgfs_rx_phyinfo_read(struct file *file,
0622                      char __user *user_buf,
0623                      size_t count, loff_t *ppos)
0624 {
0625     struct ieee80211_vif *vif = file->private_data;
0626     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0627     char buf[8];
0628     int len;
0629 
0630     len = scnprintf(buf, sizeof(buf), "0x%04x\n",
0631             mvmvif->mvm->dbgfs_rx_phyinfo);
0632 
0633     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0634 }
0635 
0636 static void iwl_dbgfs_quota_check(void *data, u8 *mac,
0637                   struct ieee80211_vif *vif)
0638 {
0639     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0640     int *ret = data;
0641 
0642     if (mvmvif->dbgfs_quota_min)
0643         *ret = -EINVAL;
0644 }
0645 
0646 static ssize_t iwl_dbgfs_quota_min_write(struct ieee80211_vif *vif, char *buf,
0647                      size_t count, loff_t *ppos)
0648 {
0649     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0650     struct iwl_mvm *mvm = mvmvif->mvm;
0651     u16 value;
0652     int ret;
0653 
0654     ret = kstrtou16(buf, 0, &value);
0655     if (ret)
0656         return ret;
0657 
0658     if (value > 95)
0659         return -EINVAL;
0660 
0661     mutex_lock(&mvm->mutex);
0662 
0663     mvmvif->dbgfs_quota_min = 0;
0664     ieee80211_iterate_interfaces(mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
0665                      iwl_dbgfs_quota_check, &ret);
0666     if (ret == 0) {
0667         mvmvif->dbgfs_quota_min = value;
0668         iwl_mvm_update_quotas(mvm, false, NULL);
0669     }
0670     mutex_unlock(&mvm->mutex);
0671 
0672     return ret ?: count;
0673 }
0674 
0675 static ssize_t iwl_dbgfs_quota_min_read(struct file *file,
0676                     char __user *user_buf,
0677                     size_t count, loff_t *ppos)
0678 {
0679     struct ieee80211_vif *vif = file->private_data;
0680     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0681     char buf[10];
0682     int len;
0683 
0684     len = scnprintf(buf, sizeof(buf), "%d\n", mvmvif->dbgfs_quota_min);
0685 
0686     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0687 }
0688 
0689 #define MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz) \
0690     _MVM_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif)
0691 #define MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \
0692     _MVM_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct ieee80211_vif)
0693 #define MVM_DEBUGFS_ADD_FILE_VIF(name, parent, mode) do {       \
0694         debugfs_create_file(#name, mode, parent, vif,       \
0695                     &iwl_dbgfs_##name##_ops);       \
0696     } while (0)
0697 
0698 MVM_DEBUGFS_READ_FILE_OPS(mac_params);
0699 MVM_DEBUGFS_READ_FILE_OPS(tx_pwr_lmt);
0700 MVM_DEBUGFS_READ_WRITE_FILE_OPS(pm_params, 32);
0701 MVM_DEBUGFS_READ_WRITE_FILE_OPS(bf_params, 256);
0702 MVM_DEBUGFS_READ_WRITE_FILE_OPS(low_latency, 10);
0703 MVM_DEBUGFS_WRITE_FILE_OPS(low_latency_force, 10);
0704 MVM_DEBUGFS_READ_WRITE_FILE_OPS(uapsd_misbehaving, 20);
0705 MVM_DEBUGFS_READ_WRITE_FILE_OPS(rx_phyinfo, 10);
0706 MVM_DEBUGFS_READ_WRITE_FILE_OPS(quota_min, 32);
0707 MVM_DEBUGFS_READ_FILE_OPS(os_device_timediff);
0708 
0709 
0710 void iwl_mvm_vif_dbgfs_register(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
0711 {
0712     struct dentry *dbgfs_dir = vif->debugfs_dir;
0713     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0714     char buf[100];
0715 
0716     /*
0717      * Check if debugfs directory already exist before creating it.
0718      * This may happen when, for example, resetting hw or suspend-resume
0719      */
0720     if (!dbgfs_dir || mvmvif->dbgfs_dir)
0721         return;
0722 
0723     mvmvif->dbgfs_dir = debugfs_create_dir("iwlmvm", dbgfs_dir);
0724     if (IS_ERR_OR_NULL(mvmvif->dbgfs_dir)) {
0725         IWL_ERR(mvm, "Failed to create debugfs directory under %pd\n",
0726             dbgfs_dir);
0727         return;
0728     }
0729 
0730     if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM &&
0731         ((vif->type == NL80211_IFTYPE_STATION && !vif->p2p) ||
0732          (vif->type == NL80211_IFTYPE_STATION && vif->p2p)))
0733         MVM_DEBUGFS_ADD_FILE_VIF(pm_params, mvmvif->dbgfs_dir, 0600);
0734 
0735     MVM_DEBUGFS_ADD_FILE_VIF(tx_pwr_lmt, mvmvif->dbgfs_dir, 0400);
0736     MVM_DEBUGFS_ADD_FILE_VIF(mac_params, mvmvif->dbgfs_dir, 0400);
0737     MVM_DEBUGFS_ADD_FILE_VIF(low_latency, mvmvif->dbgfs_dir, 0600);
0738     MVM_DEBUGFS_ADD_FILE_VIF(low_latency_force, mvmvif->dbgfs_dir, 0600);
0739     MVM_DEBUGFS_ADD_FILE_VIF(uapsd_misbehaving, mvmvif->dbgfs_dir, 0600);
0740     MVM_DEBUGFS_ADD_FILE_VIF(rx_phyinfo, mvmvif->dbgfs_dir, 0600);
0741     MVM_DEBUGFS_ADD_FILE_VIF(quota_min, mvmvif->dbgfs_dir, 0600);
0742     MVM_DEBUGFS_ADD_FILE_VIF(os_device_timediff, mvmvif->dbgfs_dir, 0400);
0743 
0744     if (vif->type == NL80211_IFTYPE_STATION && !vif->p2p &&
0745         mvmvif == mvm->bf_allowed_vif)
0746         MVM_DEBUGFS_ADD_FILE_VIF(bf_params, mvmvif->dbgfs_dir, 0600);
0747 
0748     /*
0749      * Create symlink for convenience pointing to interface specific
0750      * debugfs entries for the driver. For example, under
0751      * /sys/kernel/debug/iwlwifi/0000\:02\:00.0/iwlmvm/
0752      * find
0753      * netdev:wlan0 -> ../../../ieee80211/phy0/netdev:wlan0/iwlmvm/
0754      */
0755     snprintf(buf, 100, "../../../%pd3/%pd",
0756          dbgfs_dir,
0757          mvmvif->dbgfs_dir);
0758 
0759     mvmvif->dbgfs_slink = debugfs_create_symlink(dbgfs_dir->d_name.name,
0760                              mvm->debugfs_dir, buf);
0761 }
0762 
0763 void iwl_mvm_vif_dbgfs_clean(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
0764 {
0765     struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
0766 
0767     debugfs_remove(mvmvif->dbgfs_slink);
0768     mvmvif->dbgfs_slink = NULL;
0769 
0770     debugfs_remove_recursive(mvmvif->dbgfs_dir);
0771     mvmvif->dbgfs_dir = NULL;
0772 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!