drivers/net/wireless/ath/ath11k/debugfs_sta.c

   1 // SPDX-License-Identifier: BSD-3-Clause-Clear
   2 /*
   3  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/vmalloc.h>
   7
   8 #include "core.h"
   9 #include "peer.h"
  10 #include "debug.h"
  11 #include "dp_tx.h"
  12 #include "debug_htt_stats.h"
  13
  14 void
  15 ath11k_accumulate_per_peer_tx_stats(struct ath11k_sta *arsta,
  16                                     struct ath11k_per_peer_tx_stats *peer_stats,
  17                                     u8 legacy_rate_idx)
  18 {
  19         struct rate_info *txrate = &arsta->txrate;
  20         struct ath11k_htt_tx_stats *tx_stats;
  21         int gi, mcs, bw, nss;
  22
  23         if (!arsta->tx_stats)
  24                 return;
  25
  26         tx_stats = arsta->tx_stats;
  27         gi = FIELD_GET(RATE_INFO_FLAGS_SHORT_GI, arsta->txrate.flags);
  28         mcs = txrate->mcs;
  29         bw = ath11k_mac_mac80211_bw_to_ath11k_bw(txrate->bw);
  30         nss = txrate->nss - 1;
  31
  32 #define STATS_OP_FMT(name) tx_stats->stats[ATH11K_STATS_TYPE_##name]
  33
  34         if (txrate->flags & RATE_INFO_FLAGS_HE_MCS) {
  35                 STATS_OP_FMT(SUCC).he[0][mcs] += peer_stats->succ_bytes;
  36                 STATS_OP_FMT(SUCC).he[1][mcs] += peer_stats->succ_pkts;
  37                 STATS_OP_FMT(FAIL).he[0][mcs] += peer_stats->failed_bytes;
  38                 STATS_OP_FMT(FAIL).he[1][mcs] += peer_stats->failed_pkts;
  39                 STATS_OP_FMT(RETRY).he[0][mcs] += peer_stats->retry_bytes;
  40                 STATS_OP_FMT(RETRY).he[1][mcs] += peer_stats->retry_pkts;
  41         } else if (txrate->flags & RATE_INFO_FLAGS_VHT_MCS) {
  42                 STATS_OP_FMT(SUCC).vht[0][mcs] += peer_stats->succ_bytes;
  43                 STATS_OP_FMT(SUCC).vht[1][mcs] += peer_stats->succ_pkts;
  44                 STATS_OP_FMT(FAIL).vht[0][mcs] += peer_stats->failed_bytes;
  45                 STATS_OP_FMT(FAIL).vht[1][mcs] += peer_stats->failed_pkts;
  46                 STATS_OP_FMT(RETRY).vht[0][mcs] += peer_stats->retry_bytes;
  47                 STATS_OP_FMT(RETRY).vht[1][mcs] += peer_stats->retry_pkts;
  48         } else if (txrate->flags & RATE_INFO_FLAGS_MCS) {
  49                 STATS_OP_FMT(SUCC).ht[0][mcs] += peer_stats->succ_bytes;
  50                 STATS_OP_FMT(SUCC).ht[1][mcs] += peer_stats->succ_pkts;
  51                 STATS_OP_FMT(FAIL).ht[0][mcs] += peer_stats->failed_bytes;
  52                 STATS_OP_FMT(FAIL).ht[1][mcs] += peer_stats->failed_pkts;
  53                 STATS_OP_FMT(RETRY).ht[0][mcs] += peer_stats->retry_bytes;
  54                 STATS_OP_FMT(RETRY).ht[1][mcs] += peer_stats->retry_pkts;
  55         } else {
  56                 mcs = legacy_rate_idx;
  57
  58                 STATS_OP_FMT(SUCC).legacy[0][mcs] += peer_stats->succ_bytes;
  59                 STATS_OP_FMT(SUCC).legacy[1][mcs] += peer_stats->succ_pkts;
  60                 STATS_OP_FMT(FAIL).legacy[0][mcs] += peer_stats->failed_bytes;
  61                 STATS_OP_FMT(FAIL).legacy[1][mcs] += peer_stats->failed_pkts;
  62                 STATS_OP_FMT(RETRY).legacy[0][mcs] += peer_stats->retry_bytes;
  63                 STATS_OP_FMT(RETRY).legacy[1][mcs] += peer_stats->retry_pkts;
  64         }
  65
  66         if (peer_stats->is_ampdu) {
  67                 tx_stats->ba_fails += peer_stats->ba_fails;
  68
  69                 if (txrate->flags & RATE_INFO_FLAGS_HE_MCS) {
  70                         STATS_OP_FMT(AMPDU).he[0][mcs] +=
  71                         peer_stats->succ_bytes + peer_stats->retry_bytes;
  72                         STATS_OP_FMT(AMPDU).he[1][mcs] +=
  73                         peer_stats->succ_pkts + peer_stats->retry_pkts;
  74                 } else if (txrate->flags & RATE_INFO_FLAGS_MCS) {
  75                         STATS_OP_FMT(AMPDU).ht[0][mcs] +=
  76                         peer_stats->succ_bytes + peer_stats->retry_bytes;
  77                         STATS_OP_FMT(AMPDU).ht[1][mcs] +=
  78                         peer_stats->succ_pkts + peer_stats->retry_pkts;
  79                 } else {
  80                         STATS_OP_FMT(AMPDU).vht[0][mcs] +=
  81                         peer_stats->succ_bytes + peer_stats->retry_bytes;
  82                         STATS_OP_FMT(AMPDU).vht[1][mcs] +=
  83                         peer_stats->succ_pkts + peer_stats->retry_pkts;
  84                 }
  85                 STATS_OP_FMT(AMPDU).bw[0][bw] +=
  86                         peer_stats->succ_bytes + peer_stats->retry_bytes;
  87                 STATS_OP_FMT(AMPDU).nss[0][nss] +=
  88                         peer_stats->succ_bytes + peer_stats->retry_bytes;
  89                 STATS_OP_FMT(AMPDU).gi[0][gi] +=
  90                         peer_stats->succ_bytes + peer_stats->retry_bytes;
  91                 STATS_OP_FMT(AMPDU).bw[1][bw] +=
  92                         peer_stats->succ_pkts + peer_stats->retry_pkts;
  93                 STATS_OP_FMT(AMPDU).nss[1][nss] +=
  94                         peer_stats->succ_pkts + peer_stats->retry_pkts;
  95                 STATS_OP_FMT(AMPDU).gi[1][gi] +=
  96                         peer_stats->succ_pkts + peer_stats->retry_pkts;
  97         } else {
  98                 tx_stats->ack_fails += peer_stats->ba_fails;
  99         }
 100
 101         STATS_OP_FMT(SUCC).bw[0][bw] += peer_stats->succ_bytes;
 102         STATS_OP_FMT(SUCC).nss[0][nss] += peer_stats->succ_bytes;
 103         STATS_OP_FMT(SUCC).gi[0][gi] += peer_stats->succ_bytes;
 104
 105         STATS_OP_FMT(SUCC).bw[1][bw] += peer_stats->succ_pkts;
 106         STATS_OP_FMT(SUCC).nss[1][nss] += peer_stats->succ_pkts;
 107         STATS_OP_FMT(SUCC).gi[1][gi] += peer_stats->succ_pkts;
 108
 109         STATS_OP_FMT(FAIL).bw[0][bw] += peer_stats->failed_bytes;
 110         STATS_OP_FMT(FAIL).nss[0][nss] += peer_stats->failed_bytes;
 111         STATS_OP_FMT(FAIL).gi[0][gi] += peer_stats->failed_bytes;
 112
 113         STATS_OP_FMT(FAIL).bw[1][bw] += peer_stats->failed_pkts;
 114         STATS_OP_FMT(FAIL).nss[1][nss] += peer_stats->failed_pkts;
 115         STATS_OP_FMT(FAIL).gi[1][gi] += peer_stats->failed_pkts;
 116
 117         STATS_OP_FMT(RETRY).bw[0][bw] += peer_stats->retry_bytes;
 118         STATS_OP_FMT(RETRY).nss[0][nss] += peer_stats->retry_bytes;
 119         STATS_OP_FMT(RETRY).gi[0][gi] += peer_stats->retry_bytes;
 120
 121         STATS_OP_FMT(RETRY).bw[1][bw] += peer_stats->retry_pkts;
 122         STATS_OP_FMT(RETRY).nss[1][nss] += peer_stats->retry_pkts;
 123         STATS_OP_FMT(RETRY).gi[1][gi] += peer_stats->retry_pkts;
 124
 125         tx_stats->tx_duration += peer_stats->duration;
 126 }
 127
 128 void ath11k_update_per_peer_stats_from_txcompl(struct ath11k *ar,
 129                                                struct sk_buff *msdu,
 130                                                struct hal_tx_status *ts)
 131 {
 132         struct ath11k_base *ab = ar->ab;
 133         struct ath11k_per_peer_tx_stats *peer_stats = &ar->cached_stats;
 134         enum hal_tx_rate_stats_pkt_type pkt_type;
 135         enum hal_tx_rate_stats_sgi sgi;
 136         enum hal_tx_rate_stats_bw bw;
 137         struct ath11k_peer *peer;
 138         struct ath11k_sta *arsta;
 139         struct ieee80211_sta *sta;
 140         u16 rate;
 141         u8 rate_idx = 0;
 142         int ret;
 143         u8 mcs;
 144
 145         rcu_read_lock();
 146         spin_lock_bh(&ab->base_lock);
 147         peer = ath11k_peer_find_by_id(ab, ts->peer_id);
 148         if (!peer || !peer->sta) {
 149                 ath11k_warn(ab, "failed to find the peer\n");
 150                 spin_unlock_bh(&ab->base_lock);
 151                 rcu_read_unlock();
 152                 return;
 153         }
 154
 155         sta = peer->sta;
 156         arsta = (struct ath11k_sta *)sta->drv_priv;
 157
 158         memset(&arsta->txrate, 0, sizeof(arsta->txrate));
 159         pkt_type = FIELD_GET(HAL_TX_RATE_STATS_INFO0_PKT_TYPE,
 160                              ts->rate_stats);
 161         mcs = FIELD_GET(HAL_TX_RATE_STATS_INFO0_MCS,
 162                         ts->rate_stats);
 163         sgi = FIELD_GET(HAL_TX_RATE_STATS_INFO0_SGI,
 164                         ts->rate_stats);
 165         bw = FIELD_GET(HAL_TX_RATE_STATS_INFO0_BW, ts->rate_stats);
 166
 167         if (pkt_type == HAL_TX_RATE_STATS_PKT_TYPE_11A ||
 168             pkt_type == HAL_TX_RATE_STATS_PKT_TYPE_11B) {
 169                 ret = ath11k_mac_hw_ratecode_to_legacy_rate(mcs,
 170                                                             pkt_type,
 171                                                             &rate_idx,
 172                                                             &rate);
 173                 if (ret < 0)
 174                         goto err_out;
 175                 arsta->txrate.legacy = rate;
 176         } else if (pkt_type == HAL_TX_RATE_STATS_PKT_TYPE_11N) {
 177                 if (mcs > 7) {
 178                         ath11k_warn(ab, "Invalid HT mcs index %d\n", mcs);
 179                         goto err_out;
 180                 }
 181
 182                 arsta->txrate.mcs = mcs + 8 * (arsta->last_txrate.nss - 1);
 183                 arsta->txrate.flags = RATE_INFO_FLAGS_MCS;
 184                 if (sgi)
 185                         arsta->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
 186         } else if (pkt_type == HAL_TX_RATE_STATS_PKT_TYPE_11AC) {
 187                 if (mcs > 9) {
 188                         ath11k_warn(ab, "Invalid VHT mcs index %d\n", mcs);
 189                         goto err_out;
 190                 }
 191
 192                 arsta->txrate.mcs = mcs;
 193                 arsta->txrate.flags = RATE_INFO_FLAGS_VHT_MCS;
 194                 if (sgi)
 195                         arsta->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
 196         } else if (pkt_type == HAL_TX_RATE_STATS_PKT_TYPE_11AX) {
 197                 /* TODO */
 198         }
 199
 200         arsta->txrate.nss = arsta->last_txrate.nss;
 201         arsta->txrate.bw = ath11k_mac_bw_to_mac80211_bw(bw);
 202
 203         ath11k_accumulate_per_peer_tx_stats(arsta, peer_stats, rate_idx);
 204 err_out:
 205         spin_unlock_bh(&ab->base_lock);
 206         rcu_read_unlock();
 207 }
 208
 209 static ssize_t ath11k_dbg_sta_dump_tx_stats(struct file *file,
 210                                             char __user *user_buf,
 211                                             size_t count, loff_t *ppos)
 212 {
 213         struct ieee80211_sta *sta = file->private_data;
 214         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 215         struct ath11k *ar = arsta->arvif->ar;
 216         struct ath11k_htt_data_stats *stats;
 217         static const char *str_name[ATH11K_STATS_TYPE_MAX] = {"succ", "fail",
 218                                                               "retry", "ampdu"};
 219         static const char *str[ATH11K_COUNTER_TYPE_MAX] = {"bytes", "packets"};
 220         int len = 0, i, j, k, retval = 0;
 221         const int size = 2 * 4096;
 222         char *buf;
 223
 224         if (!arsta->tx_stats)
 225                 return -ENOENT;
 226
 227         buf = kzalloc(size, GFP_KERNEL);
 228         if (!buf)
 229                 return -ENOMEM;
 230
 231         mutex_lock(&ar->conf_mutex);
 232
 233         spin_lock_bh(&ar->data_lock);
 234         for (k = 0; k < ATH11K_STATS_TYPE_MAX; k++) {
 235                 for (j = 0; j < ATH11K_COUNTER_TYPE_MAX; j++) {
 236                         stats = &arsta->tx_stats->stats[k];
 237                         len += scnprintf(buf + len, size - len, "%s_%s\n",
 238                                          str_name[k],
 239                                          str[j]);
 240                         len += scnprintf(buf + len, size - len,
 241                                          " HE MCS %s\n",
 242                                          str[j]);
 243                         for (i = 0; i < ATH11K_HE_MCS_NUM; i++)
 244                                 len += scnprintf(buf + len, size - len,
 245                                                  "  %llu ",
 246                                                  stats->he[j][i]);
 247                         len += scnprintf(buf + len, size - len, "\n");
 248                         len += scnprintf(buf + len, size - len,
 249                                          " VHT MCS %s\n",
 250                                          str[j]);
 251                         for (i = 0; i < ATH11K_VHT_MCS_NUM; i++)
 252                                 len += scnprintf(buf + len, size - len,
 253                                                  "  %llu ",
 254                                                  stats->vht[j][i]);
 255                         len += scnprintf(buf + len, size - len, "\n");
 256                         len += scnprintf(buf + len, size - len, " HT MCS %s\n",
 257                                          str[j]);
 258                         for (i = 0; i < ATH11K_HT_MCS_NUM; i++)
 259                                 len += scnprintf(buf + len, size - len,
 260                                                  "  %llu ", stats->ht[j][i]);
 261                         len += scnprintf(buf + len, size - len, "\n");
 262                         len += scnprintf(buf + len, size - len,
 263                                         " BW %s (20,40,80,160 MHz)\n", str[j]);
 264                         len += scnprintf(buf + len, size - len,
 265                                          "  %llu %llu %llu %llu\n",
 266                                          stats->bw[j][0], stats->bw[j][1],
 267                                          stats->bw[j][2], stats->bw[j][3]);
 268                         len += scnprintf(buf + len, size - len,
 269                                          " NSS %s (1x1,2x2,3x3,4x4)\n", str[j]);
 270                         len += scnprintf(buf + len, size - len,
 271                                          "  %llu %llu %llu %llu\n",
 272                                          stats->nss[j][0], stats->nss[j][1],
 273                                          stats->nss[j][2], stats->nss[j][3]);
 274                         len += scnprintf(buf + len, size - len,
 275                                          " GI %s (0.4us,0.8us,1.6us,3.2us)\n",
 276                                          str[j]);
 277                         len += scnprintf(buf + len, size - len,
 278                                          "  %llu %llu %llu %llu\n",
 279                                          stats->gi[j][0], stats->gi[j][1],
 280                                          stats->gi[j][2], stats->gi[j][3]);
 281                         len += scnprintf(buf + len, size - len,
 282                                          " legacy rate %s (1,2 ... Mbps)\n  ",
 283                                          str[j]);
 284                         for (i = 0; i < ATH11K_LEGACY_NUM; i++)
 285                                 len += scnprintf(buf + len, size - len, "%llu ",
 286                                                  stats->legacy[j][i]);
 287                         len += scnprintf(buf + len, size - len, "\n");
 288                 }
 289         }
 290
 291         len += scnprintf(buf + len, size - len,
 292                          "\nTX duration\n %llu usecs\n",
 293                          arsta->tx_stats->tx_duration);
 294         len += scnprintf(buf + len, size - len,
 295                         "BA fails\n %llu\n", arsta->tx_stats->ba_fails);
 296         len += scnprintf(buf + len, size - len,
 297                         "ack fails\n %llu\n", arsta->tx_stats->ack_fails);
 298         spin_unlock_bh(&ar->data_lock);
 299
 300         if (len > size)
 301                 len = size;
 302         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 303         kfree(buf);
 304
 305         mutex_unlock(&ar->conf_mutex);
 306         return retval;
 307 }
 308
 309 static const struct file_operations fops_tx_stats = {
 310         .read = ath11k_dbg_sta_dump_tx_stats,
 311         .open = simple_open,
 312         .owner = THIS_MODULE,
 313         .llseek = default_llseek,
 314 };
 315
 316 static ssize_t ath11k_dbg_sta_dump_rx_stats(struct file *file,
 317                                             char __user *user_buf,
 318                                             size_t count, loff_t *ppos)
 319 {
 320         struct ieee80211_sta *sta = file->private_data;
 321         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 322         struct ath11k *ar = arsta->arvif->ar;
 323         struct ath11k_rx_peer_stats *rx_stats = arsta->rx_stats;
 324         int len = 0, i, retval = 0;
 325         const int size = 4096;
 326         char *buf;
 327
 328         if (!rx_stats)
 329                 return -ENOENT;
 330
 331         buf = kzalloc(size, GFP_KERNEL);
 332         if (!buf)
 333                 return -ENOMEM;
 334
 335         mutex_lock(&ar->conf_mutex);
 336         spin_lock_bh(&ar->ab->base_lock);
 337
 338         len += scnprintf(buf + len, size - len, "RX peer stats:\n");
 339         len += scnprintf(buf + len, size - len, "Num of MSDUs: %llu\n",
 340                          rx_stats->num_msdu);
 341         len += scnprintf(buf + len, size - len, "Num of MSDUs with TCP L4: %llu\n",
 342                          rx_stats->tcp_msdu_count);
 343         len += scnprintf(buf + len, size - len, "Num of MSDUs with UDP L4: %llu\n",
 344                          rx_stats->udp_msdu_count);
 345         len += scnprintf(buf + len, size - len, "Num of MSDUs part of AMPDU: %llu\n",
 346                          rx_stats->ampdu_msdu_count);
 347         len += scnprintf(buf + len, size - len, "Num of MSDUs not part of AMPDU: %llu\n",
 348                          rx_stats->non_ampdu_msdu_count);
 349         len += scnprintf(buf + len, size - len, "Num of MSDUs using STBC: %llu\n",
 350                          rx_stats->stbc_count);
 351         len += scnprintf(buf + len, size - len, "Num of MSDUs beamformed: %llu\n",
 352                          rx_stats->beamformed_count);
 353         len += scnprintf(buf + len, size - len, "Num of MPDUs with FCS ok: %llu\n",
 354                          rx_stats->num_mpdu_fcs_ok);
 355         len += scnprintf(buf + len, size - len, "Num of MPDUs with FCS error: %llu\n",
 356                          rx_stats->num_mpdu_fcs_err);
 357         len += scnprintf(buf + len, size - len,
 358                          "GI: 0.8us %llu 0.4us %llu 1.6us %llu 3.2us %llu\n",
 359                          rx_stats->gi_count[0], rx_stats->gi_count[1],
 360                          rx_stats->gi_count[2], rx_stats->gi_count[3]);
 361         len += scnprintf(buf + len, size - len,
 362                          "BW: 20Mhz %llu 40Mhz %llu 80Mhz %llu 160Mhz %llu\n",
 363                          rx_stats->bw_count[0], rx_stats->bw_count[1],
 364                          rx_stats->bw_count[2], rx_stats->bw_count[3]);
 365         len += scnprintf(buf + len, size - len, "BCC %llu LDPC %llu\n",
 366                          rx_stats->coding_count[0], rx_stats->coding_count[1]);
 367         len += scnprintf(buf + len, size - len,
 368                          "preamble: 11A %llu 11B %llu 11N %llu 11AC %llu 11AX %llu\n",
 369                          rx_stats->pream_cnt[0], rx_stats->pream_cnt[1],
 370                          rx_stats->pream_cnt[2], rx_stats->pream_cnt[3],
 371                          rx_stats->pream_cnt[4]);
 372         len += scnprintf(buf + len, size - len,
 373                          "reception type: SU %llu MU_MIMO %llu MU_OFDMA %llu MU_OFDMA_MIMO %llu\n",
 374                          rx_stats->reception_type[0], rx_stats->reception_type[1],
 375                          rx_stats->reception_type[2], rx_stats->reception_type[3]);
 376         len += scnprintf(buf + len, size - len, "TID(0-15) Legacy TID(16):");
 377         for (i = 0; i <= IEEE80211_NUM_TIDS; i++)
 378                 len += scnprintf(buf + len, size - len, "%llu ", rx_stats->tid_count[i]);
 379         len += scnprintf(buf + len, size - len, "\nMCS(0-11) Legacy MCS(12):");
 380         for (i = 0; i < HAL_RX_MAX_MCS + 1; i++)
 381                 len += scnprintf(buf + len, size - len, "%llu ", rx_stats->mcs_count[i]);
 382         len += scnprintf(buf + len, size - len, "\nNSS(1-8):");
 383         for (i = 0; i < HAL_RX_MAX_NSS; i++)
 384                 len += scnprintf(buf + len, size - len, "%llu ", rx_stats->nss_count[i]);
 385         len += scnprintf(buf + len, size - len, "\nRX Duration:%llu ",
 386                          rx_stats->rx_duration);
 387         len += scnprintf(buf + len, size - len,
 388                          "\nDCM: %llu\nRU: 26 %llu 52: %llu 106: %llu 242: %llu 484: %llu 996: %llu\n",
 389                          rx_stats->dcm_count, rx_stats->ru_alloc_cnt[0],
 390                          rx_stats->ru_alloc_cnt[1], rx_stats->ru_alloc_cnt[2],
 391                          rx_stats->ru_alloc_cnt[3], rx_stats->ru_alloc_cnt[4],
 392                          rx_stats->ru_alloc_cnt[5]);
 393
 394         len += scnprintf(buf + len, size - len, "\n");
 395
 396         spin_unlock_bh(&ar->ab->base_lock);
 397
 398         if (len > size)
 399                 len = size;
 400         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 401         kfree(buf);
 402
 403         mutex_unlock(&ar->conf_mutex);
 404         return retval;
 405 }
 406
 407 static const struct file_operations fops_rx_stats = {
 408         .read = ath11k_dbg_sta_dump_rx_stats,
 409         .open = simple_open,
 410         .owner = THIS_MODULE,
 411         .llseek = default_llseek,
 412 };
 413
 414 static int
 415 ath11k_dbg_sta_open_htt_peer_stats(struct inode *inode, struct file *file)
 416 {
 417         struct ieee80211_sta *sta = inode->i_private;
 418         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 419         struct ath11k *ar = arsta->arvif->ar;
 420         struct debug_htt_stats_req *stats_req;
 421         int ret;
 422
 423         stats_req = vzalloc(sizeof(*stats_req) + ATH11K_HTT_STATS_BUF_SIZE);
 424         if (!stats_req)
 425                 return -ENOMEM;
 426
 427         mutex_lock(&ar->conf_mutex);
 428         ar->debug.htt_stats.stats_req = stats_req;
 429         stats_req->type = ATH11K_DBG_HTT_EXT_STATS_PEER_INFO;
 430         memcpy(stats_req->peer_addr, sta->addr, ETH_ALEN);
 431         ret = ath11k_dbg_htt_stats_req(ar);
 432         mutex_unlock(&ar->conf_mutex);
 433         if (ret < 0)
 434                 goto out;
 435
 436         file->private_data = stats_req;
 437         return 0;
 438 out:
 439         vfree(stats_req);
 440         ar->debug.htt_stats.stats_req = NULL;
 441         return ret;
 442 }
 443
 444 static int
 445 ath11k_dbg_sta_release_htt_peer_stats(struct inode *inode, struct file *file)
 446 {
 447         struct ieee80211_sta *sta = inode->i_private;
 448         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 449         struct ath11k *ar = arsta->arvif->ar;
 450
 451         mutex_lock(&ar->conf_mutex);
 452         vfree(file->private_data);
 453         ar->debug.htt_stats.stats_req = NULL;
 454         mutex_unlock(&ar->conf_mutex);
 455
 456         return 0;
 457 }
 458
 459 static ssize_t ath11k_dbg_sta_read_htt_peer_stats(struct file *file,
 460                                                   char __user *user_buf,
 461                                                   size_t count, loff_t *ppos)
 462 {
 463         struct debug_htt_stats_req *stats_req = file->private_data;
 464         char *buf;
 465         u32 length = 0;
 466
 467         buf = stats_req->buf;
 468         length = min_t(u32, stats_req->buf_len, ATH11K_HTT_STATS_BUF_SIZE);
 469         return simple_read_from_buffer(user_buf, count, ppos, buf, length);
 470 }
 471
 472 static const struct file_operations fops_htt_peer_stats = {
 473         .open = ath11k_dbg_sta_open_htt_peer_stats,
 474         .release = ath11k_dbg_sta_release_htt_peer_stats,
 475         .read = ath11k_dbg_sta_read_htt_peer_stats,
 476         .owner = THIS_MODULE,
 477         .llseek = default_llseek,
 478 };
 479
 480 static ssize_t ath11k_dbg_sta_write_peer_pktlog(struct file *file,
 481                                                 const char __user *buf,
 482                                                 size_t count, loff_t *ppos)
 483 {
 484         struct ieee80211_sta *sta = file->private_data;
 485         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 486         struct ath11k *ar = arsta->arvif->ar;
 487         int ret, enable;
 488
 489         mutex_lock(&ar->conf_mutex);
 490
 491         if (ar->state != ATH11K_STATE_ON) {
 492                 ret = -ENETDOWN;
 493                 goto out;
 494         }
 495
 496         ret = kstrtoint_from_user(buf, count, 0, &enable);
 497         if (ret)
 498                 goto out;
 499
 500         ar->debug.pktlog_peer_valid = enable;
 501         memcpy(ar->debug.pktlog_peer_addr, sta->addr, ETH_ALEN);
 502
 503         /* Send peer based pktlog enable/disable */
 504         ret = ath11k_wmi_pdev_peer_pktlog_filter(ar, sta->addr, enable);
 505         if (ret) {
 506                 ath11k_warn(ar->ab, "failed to set peer pktlog filter %pM: %d\n",
 507                             sta->addr, ret);
 508                 goto out;
 509         }
 510
 511         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "peer pktlog filter set to %d\n",
 512                    enable);
 513         ret = count;
 514
 515 out:
 516         mutex_unlock(&ar->conf_mutex);
 517         return ret;
 518 }
 519
 520 static ssize_t ath11k_dbg_sta_read_peer_pktlog(struct file *file,
 521                                                char __user *ubuf,
 522                                                size_t count, loff_t *ppos)
 523 {
 524         struct ieee80211_sta *sta = file->private_data;
 525         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 526         struct ath11k *ar = arsta->arvif->ar;
 527         char buf[32] = {0};
 528         int len;
 529
 530         mutex_lock(&ar->conf_mutex);
 531         len = scnprintf(buf, sizeof(buf), "%08x %pM\n",
 532                         ar->debug.pktlog_peer_valid,
 533                         ar->debug.pktlog_peer_addr);
 534         mutex_unlock(&ar->conf_mutex);
 535
 536         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
 537 }
 538
 539 static const struct file_operations fops_peer_pktlog = {
 540         .write = ath11k_dbg_sta_write_peer_pktlog,
 541         .read = ath11k_dbg_sta_read_peer_pktlog,
 542         .open = simple_open,
 543         .owner = THIS_MODULE,
 544         .llseek = default_llseek,
 545 };
 546
 547 static ssize_t ath11k_dbg_sta_write_delba(struct file *file,
 548                                           const char __user *user_buf,
 549                                           size_t count, loff_t *ppos)
 550 {
 551         struct ieee80211_sta *sta = file->private_data;
 552         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 553         struct ath11k *ar = arsta->arvif->ar;
 554         u32 tid, initiator, reason;
 555         int ret;
 556         char buf[64] = {0};
 557
 558         ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
 559                                      user_buf, count);
 560         if (ret <= 0)
 561                 return ret;
 562
 563         ret = sscanf(buf, "%u %u %u", &tid, &initiator, &reason);
 564         if (ret != 3)
 565                 return -EINVAL;
 566
 567         /* Valid TID values are 0 through 15 */
 568         if (tid > HAL_DESC_REO_NON_QOS_TID - 1)
 569                 return -EINVAL;
 570
 571         mutex_lock(&ar->conf_mutex);
 572         if (ar->state != ATH11K_STATE_ON ||
 573             arsta->aggr_mode != ATH11K_DBG_AGGR_MODE_MANUAL) {
 574                 ret = count;
 575                 goto out;
 576         }
 577
 578         ret = ath11k_wmi_delba_send(ar, arsta->arvif->vdev_id, sta->addr,
 579                                     tid, initiator, reason);
 580         if (ret) {
 581                 ath11k_warn(ar->ab, "failed to send delba: vdev_id %u peer %pM tid %u initiator %u reason %u\n",
 582                             arsta->arvif->vdev_id, sta->addr, tid, initiator,
 583                             reason);
 584         }
 585         ret = count;
 586 out:
 587         mutex_unlock(&ar->conf_mutex);
 588         return ret;
 589 }
 590
 591 static const struct file_operations fops_delba = {
 592         .write = ath11k_dbg_sta_write_delba,
 593         .open = simple_open,
 594         .owner = THIS_MODULE,
 595         .llseek = default_llseek,
 596 };
 597
 598 static ssize_t ath11k_dbg_sta_write_addba_resp(struct file *file,
 599                                                const char __user *user_buf,
 600                                                size_t count, loff_t *ppos)
 601 {
 602         struct ieee80211_sta *sta = file->private_data;
 603         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 604         struct ath11k *ar = arsta->arvif->ar;
 605         u32 tid, status;
 606         int ret;
 607         char buf[64] = {0};
 608
 609         ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
 610                                      user_buf, count);
 611         if (ret <= 0)
 612                 return ret;
 613
 614         ret = sscanf(buf, "%u %u", &tid, &status);
 615         if (ret != 2)
 616                 return -EINVAL;
 617
 618         /* Valid TID values are 0 through 15 */
 619         if (tid > HAL_DESC_REO_NON_QOS_TID - 1)
 620                 return -EINVAL;
 621
 622         mutex_lock(&ar->conf_mutex);
 623         if (ar->state != ATH11K_STATE_ON ||
 624             arsta->aggr_mode != ATH11K_DBG_AGGR_MODE_MANUAL) {
 625                 ret = count;
 626                 goto out;
 627         }
 628
 629         ret = ath11k_wmi_addba_set_resp(ar, arsta->arvif->vdev_id, sta->addr,
 630                                         tid, status);
 631         if (ret) {
 632                 ath11k_warn(ar->ab, "failed to send addba response: vdev_id %u peer %pM tid %u status%u\n",
 633                             arsta->arvif->vdev_id, sta->addr, tid, status);
 634         }
 635         ret = count;
 636 out:
 637         mutex_unlock(&ar->conf_mutex);
 638         return ret;
 639 }
 640
 641 static const struct file_operations fops_addba_resp = {
 642         .write = ath11k_dbg_sta_write_addba_resp,
 643         .open = simple_open,
 644         .owner = THIS_MODULE,
 645         .llseek = default_llseek,
 646 };
 647
 648 static ssize_t ath11k_dbg_sta_write_addba(struct file *file,
 649                                           const char __user *user_buf,
 650                                           size_t count, loff_t *ppos)
 651 {
 652         struct ieee80211_sta *sta = file->private_data;
 653         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 654         struct ath11k *ar = arsta->arvif->ar;
 655         u32 tid, buf_size;
 656         int ret;
 657         char buf[64] = {0};
 658
 659         ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
 660                                      user_buf, count);
 661         if (ret <= 0)
 662                 return ret;
 663
 664         ret = sscanf(buf, "%u %u", &tid, &buf_size);
 665         if (ret != 2)
 666                 return -EINVAL;
 667
 668         /* Valid TID values are 0 through 15 */
 669         if (tid > HAL_DESC_REO_NON_QOS_TID - 1)
 670                 return -EINVAL;
 671
 672         mutex_lock(&ar->conf_mutex);
 673         if (ar->state != ATH11K_STATE_ON ||
 674             arsta->aggr_mode != ATH11K_DBG_AGGR_MODE_MANUAL) {
 675                 ret = count;
 676                 goto out;
 677         }
 678
 679         ret = ath11k_wmi_addba_send(ar, arsta->arvif->vdev_id, sta->addr,
 680                                     tid, buf_size);
 681         if (ret) {
 682                 ath11k_warn(ar->ab, "failed to send addba request: vdev_id %u peer %pM tid %u buf_size %u\n",
 683                             arsta->arvif->vdev_id, sta->addr, tid, buf_size);
 684         }
 685
 686         ret = count;
 687 out:
 688         mutex_unlock(&ar->conf_mutex);
 689         return ret;
 690 }
 691
 692 static const struct file_operations fops_addba = {
 693         .write = ath11k_dbg_sta_write_addba,
 694         .open = simple_open,
 695         .owner = THIS_MODULE,
 696         .llseek = default_llseek,
 697 };
 698
 699 static ssize_t ath11k_dbg_sta_read_aggr_mode(struct file *file,
 700                                              char __user *user_buf,
 701                                              size_t count, loff_t *ppos)
 702 {
 703         struct ieee80211_sta *sta = file->private_data;
 704         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 705         struct ath11k *ar = arsta->arvif->ar;
 706         char buf[64];
 707         int len = 0;
 708
 709         mutex_lock(&ar->conf_mutex);
 710         len = scnprintf(buf, sizeof(buf) - len,
 711                         "aggregation mode: %s\n\n%s\n%s\n",
 712                         (arsta->aggr_mode == ATH11K_DBG_AGGR_MODE_AUTO) ?
 713                         "auto" : "manual", "auto = 0", "manual = 1");
 714         mutex_unlock(&ar->conf_mutex);
 715
 716         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 717 }
 718
 719 static ssize_t ath11k_dbg_sta_write_aggr_mode(struct file *file,
 720                                               const char __user *user_buf,
 721                                               size_t count, loff_t *ppos)
 722 {
 723         struct ieee80211_sta *sta = file->private_data;
 724         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 725         struct ath11k *ar = arsta->arvif->ar;
 726         u32 aggr_mode;
 727         int ret;
 728
 729         if (kstrtouint_from_user(user_buf, count, 0, &aggr_mode))
 730                 return -EINVAL;
 731
 732         if (aggr_mode >= ATH11K_DBG_AGGR_MODE_MAX)
 733                 return -EINVAL;
 734
 735         mutex_lock(&ar->conf_mutex);
 736         if (ar->state != ATH11K_STATE_ON ||
 737             aggr_mode == arsta->aggr_mode) {
 738                 ret = count;
 739                 goto out;
 740         }
 741
 742         ret = ath11k_wmi_addba_clear_resp(ar, arsta->arvif->vdev_id, sta->addr);
 743         if (ret) {
 744                 ath11k_warn(ar->ab, "failed to clear addba session ret: %d\n",
 745                             ret);
 746                 goto out;
 747         }
 748
 749         arsta->aggr_mode = aggr_mode;
 750 out:
 751         mutex_unlock(&ar->conf_mutex);
 752         return ret;
 753 }
 754
 755 static const struct file_operations fops_aggr_mode = {
 756         .read = ath11k_dbg_sta_read_aggr_mode,
 757         .write = ath11k_dbg_sta_write_aggr_mode,
 758         .open = simple_open,
 759         .owner = THIS_MODULE,
 760         .llseek = default_llseek,
 761 };
 762
 763 static ssize_t
 764 ath11k_write_htt_peer_stats_reset(struct file *file,
 765                                   const char __user *user_buf,
 766                                   size_t count, loff_t *ppos)
 767 {
 768         struct ieee80211_sta *sta = file->private_data;
 769         struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
 770         struct ath11k *ar = arsta->arvif->ar;
 771         struct htt_ext_stats_cfg_params cfg_params = { 0 };
 772         int ret;
 773         u8 type;
 774
 775         ret = kstrtou8_from_user(user_buf, count, 0, &type);
 776         if (ret)
 777                 return ret;
 778
 779         if (!type)
 780                 return ret;
 781
 782         mutex_lock(&ar->conf_mutex);
 783         cfg_params.cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR;
 784         cfg_params.cfg0 |= FIELD_PREP(GENMASK(15, 1),
 785                                 HTT_PEER_STATS_REQ_MODE_FLUSH_TQM);
 786
 787         cfg_params.cfg1 = HTT_STAT_DEFAULT_PEER_REQ_TYPE;
 788
 789         cfg_params.cfg2 |= FIELD_PREP(GENMASK(7, 0), sta->addr[0]);
 790         cfg_params.cfg2 |= FIELD_PREP(GENMASK(15, 8), sta->addr[1]);
 791         cfg_params.cfg2 |= FIELD_PREP(GENMASK(23, 16), sta->addr[2]);
 792         cfg_params.cfg2 |= FIELD_PREP(GENMASK(31, 24), sta->addr[3]);
 793
 794         cfg_params.cfg3 |= FIELD_PREP(GENMASK(7, 0), sta->addr[4]);
 795         cfg_params.cfg3 |= FIELD_PREP(GENMASK(15, 8), sta->addr[5]);
 796
 797         cfg_params.cfg3 |= ATH11K_HTT_PEER_STATS_RESET;
 798
 799         ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar,
 800                                                  ATH11K_DBG_HTT_EXT_STATS_PEER_INFO,
 801                                                  &cfg_params,
 802                                                  0ULL);
 803         if (ret) {
 804                 ath11k_warn(ar->ab, "failed to send htt peer stats request: %d\n", ret);
 805                 mutex_unlock(&ar->conf_mutex);
 806                 return ret;
 807         }
 808
 809         mutex_unlock(&ar->conf_mutex);
 810
 811         ret = count;
 812
 813         return ret;
 814 }
 815
 816 static const struct file_operations fops_htt_peer_stats_reset = {
 817         .write = ath11k_write_htt_peer_stats_reset,
 818         .open = simple_open,
 819         .owner = THIS_MODULE,
 820         .llseek = default_llseek,
 821 };
 822
 823 void ath11k_sta_add_debugfs(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 824                             struct ieee80211_sta *sta, struct dentry *dir)
 825 {
 826         struct ath11k *ar = hw->priv;
 827
 828         if (ath11k_debug_is_extd_tx_stats_enabled(ar))
 829                 debugfs_create_file("tx_stats", 0400, dir, sta,
 830                                     &fops_tx_stats);
 831         if (ath11k_debug_is_extd_rx_stats_enabled(ar))
 832                 debugfs_create_file("rx_stats", 0400, dir, sta,
 833                                     &fops_rx_stats);
 834
 835         debugfs_create_file("htt_peer_stats", 0400, dir, sta,
 836                             &fops_htt_peer_stats);
 837
 838         debugfs_create_file("peer_pktlog", 0644, dir, sta,
 839                             &fops_peer_pktlog);
 840
 841         debugfs_create_file("aggr_mode", 0644, dir, sta, &fops_aggr_mode);
 842         debugfs_create_file("addba", 0200, dir, sta, &fops_addba);
 843         debugfs_create_file("addba_resp", 0200, dir, sta, &fops_addba_resp);
 844         debugfs_create_file("delba", 0200, dir, sta, &fops_delba);
 845
 846         if (test_bit(WMI_TLV_SERVICE_PER_PEER_HTT_STATS_RESET,
 847                      ar->ab->wmi_ab.svc_map))
 848                 debugfs_create_file("htt_peer_stats_reset", 0600, dir, sta,
 849                                     &fops_htt_peer_stats_reset);
 850 }