linux/drivers/net/wireless/ath/ath10k/debugfs_sta.c
<<
>>
Prefs
   1// SPDX-License-Identifier: ISC
   2/*
   3 * Copyright (c) 2014-2017 Qualcomm Atheros, Inc.
   4 * Copyright (c) 2018, The Linux Foundation. All rights reserved.
   5 */
   6
   7#include "core.h"
   8#include "wmi-ops.h"
   9#include "txrx.h"
  10#include "debug.h"
  11
  12static void ath10k_rx_stats_update_amsdu_subfrm(struct ath10k *ar,
  13                                                struct ath10k_sta_tid_stats *stats,
  14                                                u32 msdu_count)
  15{
  16        if (msdu_count == 1)
  17                stats->rx_pkt_amsdu[ATH10K_AMSDU_SUBFRM_NUM_1]++;
  18        else if (msdu_count == 2)
  19                stats->rx_pkt_amsdu[ATH10K_AMSDU_SUBFRM_NUM_2]++;
  20        else if (msdu_count == 3)
  21                stats->rx_pkt_amsdu[ATH10K_AMSDU_SUBFRM_NUM_3]++;
  22        else if (msdu_count == 4)
  23                stats->rx_pkt_amsdu[ATH10K_AMSDU_SUBFRM_NUM_4]++;
  24        else if (msdu_count > 4)
  25                stats->rx_pkt_amsdu[ATH10K_AMSDU_SUBFRM_NUM_MORE]++;
  26}
  27
  28static void ath10k_rx_stats_update_ampdu_subfrm(struct ath10k *ar,
  29                                                struct ath10k_sta_tid_stats *stats,
  30                                                u32 mpdu_count)
  31{
  32        if (mpdu_count <= 10)
  33                stats->rx_pkt_ampdu[ATH10K_AMPDU_SUBFRM_NUM_10]++;
  34        else if (mpdu_count <= 20)
  35                stats->rx_pkt_ampdu[ATH10K_AMPDU_SUBFRM_NUM_20]++;
  36        else if (mpdu_count <= 30)
  37                stats->rx_pkt_ampdu[ATH10K_AMPDU_SUBFRM_NUM_30]++;
  38        else if (mpdu_count <= 40)
  39                stats->rx_pkt_ampdu[ATH10K_AMPDU_SUBFRM_NUM_40]++;
  40        else if (mpdu_count <= 50)
  41                stats->rx_pkt_ampdu[ATH10K_AMPDU_SUBFRM_NUM_50]++;
  42        else if (mpdu_count <= 60)
  43                stats->rx_pkt_ampdu[ATH10K_AMPDU_SUBFRM_NUM_60]++;
  44        else if (mpdu_count > 60)
  45                stats->rx_pkt_ampdu[ATH10K_AMPDU_SUBFRM_NUM_MORE]++;
  46}
  47
  48void ath10k_sta_update_rx_tid_stats_ampdu(struct ath10k *ar, u16 peer_id, u8 tid,
  49                                          struct htt_rx_indication_mpdu_range *ranges,
  50                                          int num_ranges)
  51{
  52        struct ath10k_sta *arsta;
  53        struct ath10k_peer *peer;
  54        int i;
  55
  56        if (tid > IEEE80211_NUM_TIDS || !(ar->sta_tid_stats_mask & BIT(tid)))
  57                return;
  58
  59        rcu_read_lock();
  60        spin_lock_bh(&ar->data_lock);
  61
  62        peer = ath10k_peer_find_by_id(ar, peer_id);
  63        if (!peer || !peer->sta)
  64                goto out;
  65
  66        arsta = (struct ath10k_sta *)peer->sta->drv_priv;
  67
  68        for (i = 0; i < num_ranges; i++)
  69                ath10k_rx_stats_update_ampdu_subfrm(ar,
  70                                                    &arsta->tid_stats[tid],
  71                                                    ranges[i].mpdu_count);
  72
  73out:
  74        spin_unlock_bh(&ar->data_lock);
  75        rcu_read_unlock();
  76}
  77
  78void ath10k_sta_update_rx_tid_stats(struct ath10k *ar, u8 *first_hdr,
  79                                    unsigned long num_msdus,
  80                                    enum ath10k_pkt_rx_err err,
  81                                    unsigned long unchain_cnt,
  82                                    unsigned long drop_cnt,
  83                                    unsigned long drop_cnt_filter,
  84                                    unsigned long queued_msdus)
  85{
  86        struct ieee80211_sta *sta;
  87        struct ath10k_sta *arsta;
  88        struct ieee80211_hdr *hdr;
  89        struct ath10k_sta_tid_stats *stats;
  90        u8 tid = IEEE80211_NUM_TIDS;
  91        bool non_data_frm = false;
  92
  93        hdr = (struct ieee80211_hdr *)first_hdr;
  94        if (!ieee80211_is_data(hdr->frame_control))
  95                non_data_frm = true;
  96
  97        if (ieee80211_is_data_qos(hdr->frame_control))
  98                tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
  99
 100        if (!(ar->sta_tid_stats_mask & BIT(tid)) || non_data_frm)
 101                return;
 102
 103        rcu_read_lock();
 104
 105        sta = ieee80211_find_sta_by_ifaddr(ar->hw, hdr->addr2, NULL);
 106        if (!sta)
 107                goto exit;
 108
 109        arsta = (struct ath10k_sta *)sta->drv_priv;
 110
 111        spin_lock_bh(&ar->data_lock);
 112        stats = &arsta->tid_stats[tid];
 113        stats->rx_pkt_from_fw += num_msdus;
 114        stats->rx_pkt_unchained += unchain_cnt;
 115        stats->rx_pkt_drop_chained += drop_cnt;
 116        stats->rx_pkt_drop_filter += drop_cnt_filter;
 117        if (err != ATH10K_PKT_RX_ERR_MAX)
 118                stats->rx_pkt_err[err] += queued_msdus;
 119        stats->rx_pkt_queued_for_mac += queued_msdus;
 120        ath10k_rx_stats_update_amsdu_subfrm(ar, &arsta->tid_stats[tid],
 121                                            num_msdus);
 122        spin_unlock_bh(&ar->data_lock);
 123
 124exit:
 125        rcu_read_unlock();
 126}
 127
 128static void ath10k_sta_update_extd_stats_rx_duration(struct ath10k *ar,
 129                                                     struct ath10k_fw_stats *stats)
 130{
 131        struct ath10k_fw_extd_stats_peer *peer;
 132        struct ieee80211_sta *sta;
 133        struct ath10k_sta *arsta;
 134
 135        rcu_read_lock();
 136        list_for_each_entry(peer, &stats->peers_extd, list) {
 137                sta = ieee80211_find_sta_by_ifaddr(ar->hw, peer->peer_macaddr,
 138                                                   NULL);
 139                if (!sta)
 140                        continue;
 141                arsta = (struct ath10k_sta *)sta->drv_priv;
 142                arsta->rx_duration += (u64)peer->rx_duration;
 143        }
 144        rcu_read_unlock();
 145}
 146
 147static void ath10k_sta_update_stats_rx_duration(struct ath10k *ar,
 148                                                struct ath10k_fw_stats *stats)
 149{
 150        struct ath10k_fw_stats_peer *peer;
 151        struct ieee80211_sta *sta;
 152        struct ath10k_sta *arsta;
 153
 154        rcu_read_lock();
 155        list_for_each_entry(peer, &stats->peers, list) {
 156                sta = ieee80211_find_sta_by_ifaddr(ar->hw, peer->peer_macaddr,
 157                                                   NULL);
 158                if (!sta)
 159                        continue;
 160                arsta = (struct ath10k_sta *)sta->drv_priv;
 161                arsta->rx_duration += (u64)peer->rx_duration;
 162        }
 163        rcu_read_unlock();
 164}
 165
 166void ath10k_sta_update_rx_duration(struct ath10k *ar,
 167                                   struct ath10k_fw_stats *stats)
 168{
 169        if (stats->extended)
 170                ath10k_sta_update_extd_stats_rx_duration(ar, stats);
 171        else
 172                ath10k_sta_update_stats_rx_duration(ar, stats);
 173}
 174
 175static ssize_t ath10k_dbg_sta_read_aggr_mode(struct file *file,
 176                                             char __user *user_buf,
 177                                             size_t count, loff_t *ppos)
 178{
 179        struct ieee80211_sta *sta = file->private_data;
 180        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 181        struct ath10k *ar = arsta->arvif->ar;
 182        char buf[32];
 183        int len = 0;
 184
 185        mutex_lock(&ar->conf_mutex);
 186        len = scnprintf(buf, sizeof(buf) - len, "aggregation mode: %s\n",
 187                        (arsta->aggr_mode == ATH10K_DBG_AGGR_MODE_AUTO) ?
 188                        "auto" : "manual");
 189        mutex_unlock(&ar->conf_mutex);
 190
 191        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 192}
 193
 194static ssize_t ath10k_dbg_sta_write_aggr_mode(struct file *file,
 195                                              const char __user *user_buf,
 196                                              size_t count, loff_t *ppos)
 197{
 198        struct ieee80211_sta *sta = file->private_data;
 199        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 200        struct ath10k *ar = arsta->arvif->ar;
 201        u32 aggr_mode;
 202        int ret;
 203
 204        if (kstrtouint_from_user(user_buf, count, 0, &aggr_mode))
 205                return -EINVAL;
 206
 207        if (aggr_mode >= ATH10K_DBG_AGGR_MODE_MAX)
 208                return -EINVAL;
 209
 210        mutex_lock(&ar->conf_mutex);
 211        if ((ar->state != ATH10K_STATE_ON) ||
 212            (aggr_mode == arsta->aggr_mode)) {
 213                ret = count;
 214                goto out;
 215        }
 216
 217        ret = ath10k_wmi_addba_clear_resp(ar, arsta->arvif->vdev_id, sta->addr);
 218        if (ret) {
 219                ath10k_warn(ar, "failed to clear addba session ret: %d\n", ret);
 220                goto out;
 221        }
 222
 223        arsta->aggr_mode = aggr_mode;
 224out:
 225        mutex_unlock(&ar->conf_mutex);
 226        return ret;
 227}
 228
 229static const struct file_operations fops_aggr_mode = {
 230        .read = ath10k_dbg_sta_read_aggr_mode,
 231        .write = ath10k_dbg_sta_write_aggr_mode,
 232        .open = simple_open,
 233        .owner = THIS_MODULE,
 234        .llseek = default_llseek,
 235};
 236
 237static ssize_t ath10k_dbg_sta_write_addba(struct file *file,
 238                                          const char __user *user_buf,
 239                                          size_t count, loff_t *ppos)
 240{
 241        struct ieee80211_sta *sta = file->private_data;
 242        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 243        struct ath10k *ar = arsta->arvif->ar;
 244        u32 tid, buf_size;
 245        int ret;
 246        char buf[64] = {0};
 247
 248        ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
 249                                     user_buf, count);
 250        if (ret <= 0)
 251                return ret;
 252
 253        ret = sscanf(buf, "%u %u", &tid, &buf_size);
 254        if (ret != 2)
 255                return -EINVAL;
 256
 257        /* Valid TID values are 0 through 15 */
 258        if (tid > HTT_DATA_TX_EXT_TID_MGMT - 2)
 259                return -EINVAL;
 260
 261        mutex_lock(&ar->conf_mutex);
 262        if ((ar->state != ATH10K_STATE_ON) ||
 263            (arsta->aggr_mode != ATH10K_DBG_AGGR_MODE_MANUAL)) {
 264                ret = count;
 265                goto out;
 266        }
 267
 268        ret = ath10k_wmi_addba_send(ar, arsta->arvif->vdev_id, sta->addr,
 269                                    tid, buf_size);
 270        if (ret) {
 271                ath10k_warn(ar, "failed to send addba request: vdev_id %u peer %pM tid %u buf_size %u\n",
 272                            arsta->arvif->vdev_id, sta->addr, tid, buf_size);
 273        }
 274
 275        ret = count;
 276out:
 277        mutex_unlock(&ar->conf_mutex);
 278        return ret;
 279}
 280
 281static const struct file_operations fops_addba = {
 282        .write = ath10k_dbg_sta_write_addba,
 283        .open = simple_open,
 284        .owner = THIS_MODULE,
 285        .llseek = default_llseek,
 286};
 287
 288static ssize_t ath10k_dbg_sta_write_addba_resp(struct file *file,
 289                                               const char __user *user_buf,
 290                                               size_t count, loff_t *ppos)
 291{
 292        struct ieee80211_sta *sta = file->private_data;
 293        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 294        struct ath10k *ar = arsta->arvif->ar;
 295        u32 tid, status;
 296        int ret;
 297        char buf[64] = {0};
 298
 299        ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
 300                                     user_buf, count);
 301        if (ret <= 0)
 302                return ret;
 303
 304        ret = sscanf(buf, "%u %u", &tid, &status);
 305        if (ret != 2)
 306                return -EINVAL;
 307
 308        /* Valid TID values are 0 through 15 */
 309        if (tid > HTT_DATA_TX_EXT_TID_MGMT - 2)
 310                return -EINVAL;
 311
 312        mutex_lock(&ar->conf_mutex);
 313        if ((ar->state != ATH10K_STATE_ON) ||
 314            (arsta->aggr_mode != ATH10K_DBG_AGGR_MODE_MANUAL)) {
 315                ret = count;
 316                goto out;
 317        }
 318
 319        ret = ath10k_wmi_addba_set_resp(ar, arsta->arvif->vdev_id, sta->addr,
 320                                        tid, status);
 321        if (ret) {
 322                ath10k_warn(ar, "failed to send addba response: vdev_id %u peer %pM tid %u status%u\n",
 323                            arsta->arvif->vdev_id, sta->addr, tid, status);
 324        }
 325        ret = count;
 326out:
 327        mutex_unlock(&ar->conf_mutex);
 328        return ret;
 329}
 330
 331static const struct file_operations fops_addba_resp = {
 332        .write = ath10k_dbg_sta_write_addba_resp,
 333        .open = simple_open,
 334        .owner = THIS_MODULE,
 335        .llseek = default_llseek,
 336};
 337
 338static ssize_t ath10k_dbg_sta_write_delba(struct file *file,
 339                                          const char __user *user_buf,
 340                                          size_t count, loff_t *ppos)
 341{
 342        struct ieee80211_sta *sta = file->private_data;
 343        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 344        struct ath10k *ar = arsta->arvif->ar;
 345        u32 tid, initiator, reason;
 346        int ret;
 347        char buf[64] = {0};
 348
 349        ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
 350                                     user_buf, count);
 351        if (ret <= 0)
 352                return ret;
 353
 354        ret = sscanf(buf, "%u %u %u", &tid, &initiator, &reason);
 355        if (ret != 3)
 356                return -EINVAL;
 357
 358        /* Valid TID values are 0 through 15 */
 359        if (tid > HTT_DATA_TX_EXT_TID_MGMT - 2)
 360                return -EINVAL;
 361
 362        mutex_lock(&ar->conf_mutex);
 363        if ((ar->state != ATH10K_STATE_ON) ||
 364            (arsta->aggr_mode != ATH10K_DBG_AGGR_MODE_MANUAL)) {
 365                ret = count;
 366                goto out;
 367        }
 368
 369        ret = ath10k_wmi_delba_send(ar, arsta->arvif->vdev_id, sta->addr,
 370                                    tid, initiator, reason);
 371        if (ret) {
 372                ath10k_warn(ar, "failed to send delba: vdev_id %u peer %pM tid %u initiator %u reason %u\n",
 373                            arsta->arvif->vdev_id, sta->addr, tid, initiator,
 374                            reason);
 375        }
 376        ret = count;
 377out:
 378        mutex_unlock(&ar->conf_mutex);
 379        return ret;
 380}
 381
 382static const struct file_operations fops_delba = {
 383        .write = ath10k_dbg_sta_write_delba,
 384        .open = simple_open,
 385        .owner = THIS_MODULE,
 386        .llseek = default_llseek,
 387};
 388
 389static ssize_t ath10k_dbg_sta_read_peer_debug_trigger(struct file *file,
 390                                                      char __user *user_buf,
 391                                                      size_t count,
 392                                                      loff_t *ppos)
 393{
 394        struct ieee80211_sta *sta = file->private_data;
 395        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 396        struct ath10k *ar = arsta->arvif->ar;
 397        char buf[8];
 398        int len = 0;
 399
 400        mutex_lock(&ar->conf_mutex);
 401        len = scnprintf(buf, sizeof(buf) - len,
 402                        "Write 1 to once trigger the debug logs\n");
 403        mutex_unlock(&ar->conf_mutex);
 404
 405        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 406}
 407
 408static ssize_t
 409ath10k_dbg_sta_write_peer_debug_trigger(struct file *file,
 410                                        const char __user *user_buf,
 411                                        size_t count, loff_t *ppos)
 412{
 413        struct ieee80211_sta *sta = file->private_data;
 414        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 415        struct ath10k *ar = arsta->arvif->ar;
 416        u8 peer_debug_trigger;
 417        int ret;
 418
 419        if (kstrtou8_from_user(user_buf, count, 0, &peer_debug_trigger))
 420                return -EINVAL;
 421
 422        if (peer_debug_trigger != 1)
 423                return -EINVAL;
 424
 425        mutex_lock(&ar->conf_mutex);
 426
 427        if (ar->state != ATH10K_STATE_ON) {
 428                ret = -ENETDOWN;
 429                goto out;
 430        }
 431
 432        ret = ath10k_wmi_peer_set_param(ar, arsta->arvif->vdev_id, sta->addr,
 433                                        WMI_PEER_DEBUG, peer_debug_trigger);
 434        if (ret) {
 435                ath10k_warn(ar, "failed to set param to trigger peer tid logs for station ret: %d\n",
 436                            ret);
 437                goto out;
 438        }
 439out:
 440        mutex_unlock(&ar->conf_mutex);
 441        return count;
 442}
 443
 444static const struct file_operations fops_peer_debug_trigger = {
 445        .open = simple_open,
 446        .read = ath10k_dbg_sta_read_peer_debug_trigger,
 447        .write = ath10k_dbg_sta_write_peer_debug_trigger,
 448        .owner = THIS_MODULE,
 449        .llseek = default_llseek,
 450};
 451
 452static ssize_t ath10k_dbg_sta_read_peer_ps_state(struct file *file,
 453                                                 char __user *user_buf,
 454                                                 size_t count, loff_t *ppos)
 455{
 456        struct ieee80211_sta *sta = file->private_data;
 457        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 458        struct ath10k *ar = arsta->arvif->ar;
 459        char buf[20];
 460        int len = 0;
 461
 462        spin_lock_bh(&ar->data_lock);
 463
 464        len = scnprintf(buf, sizeof(buf) - len, "%d\n",
 465                        arsta->peer_ps_state);
 466
 467        spin_unlock_bh(&ar->data_lock);
 468
 469        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 470}
 471
 472static const struct file_operations fops_peer_ps_state = {
 473        .open = simple_open,
 474        .read = ath10k_dbg_sta_read_peer_ps_state,
 475        .owner = THIS_MODULE,
 476        .llseek = default_llseek,
 477};
 478
 479static char *get_err_str(enum ath10k_pkt_rx_err i)
 480{
 481        switch (i) {
 482        case ATH10K_PKT_RX_ERR_FCS:
 483                return "fcs_err";
 484        case ATH10K_PKT_RX_ERR_TKIP:
 485                return "tkip_err";
 486        case ATH10K_PKT_RX_ERR_CRYPT:
 487                return "crypt_err";
 488        case ATH10K_PKT_RX_ERR_PEER_IDX_INVAL:
 489                return "peer_idx_inval";
 490        case ATH10K_PKT_RX_ERR_MAX:
 491                return "unknown";
 492        }
 493
 494        return "unknown";
 495}
 496
 497static char *get_num_ampdu_subfrm_str(enum ath10k_ampdu_subfrm_num i)
 498{
 499        switch (i) {
 500        case ATH10K_AMPDU_SUBFRM_NUM_10:
 501                return "upto 10";
 502        case ATH10K_AMPDU_SUBFRM_NUM_20:
 503                return "11-20";
 504        case ATH10K_AMPDU_SUBFRM_NUM_30:
 505                return "21-30";
 506        case ATH10K_AMPDU_SUBFRM_NUM_40:
 507                return "31-40";
 508        case ATH10K_AMPDU_SUBFRM_NUM_50:
 509                return "41-50";
 510        case ATH10K_AMPDU_SUBFRM_NUM_60:
 511                return "51-60";
 512        case ATH10K_AMPDU_SUBFRM_NUM_MORE:
 513                return ">60";
 514        case ATH10K_AMPDU_SUBFRM_NUM_MAX:
 515                return "0";
 516        }
 517
 518        return "0";
 519}
 520
 521static char *get_num_amsdu_subfrm_str(enum ath10k_amsdu_subfrm_num i)
 522{
 523        switch (i) {
 524        case ATH10K_AMSDU_SUBFRM_NUM_1:
 525                return "1";
 526        case ATH10K_AMSDU_SUBFRM_NUM_2:
 527                return "2";
 528        case ATH10K_AMSDU_SUBFRM_NUM_3:
 529                return "3";
 530        case ATH10K_AMSDU_SUBFRM_NUM_4:
 531                return "4";
 532        case ATH10K_AMSDU_SUBFRM_NUM_MORE:
 533                return ">4";
 534        case ATH10K_AMSDU_SUBFRM_NUM_MAX:
 535                return "0";
 536        }
 537
 538        return "0";
 539}
 540
 541#define PRINT_TID_STATS(_field, _tabs) \
 542        do { \
 543                int k = 0; \
 544                for (j = 0; j <= IEEE80211_NUM_TIDS; j++) { \
 545                        if (ar->sta_tid_stats_mask & BIT(j))  { \
 546                                len += scnprintf(buf + len, buf_len - len, \
 547                                                 "[%02d] %-10lu  ", \
 548                                                 j, stats[j]._field); \
 549                                k++; \
 550                                if (k % 8 == 0)  { \
 551                                        len += scnprintf(buf + len, \
 552                                                         buf_len - len, "\n"); \
 553                                        len += scnprintf(buf + len, \
 554                                                         buf_len - len, \
 555                                                         _tabs); \
 556                                } \
 557                        } \
 558                } \
 559                len += scnprintf(buf + len, buf_len - len, "\n"); \
 560        } while (0)
 561
 562static ssize_t ath10k_dbg_sta_read_tid_stats(struct file *file,
 563                                             char __user *user_buf,
 564                                             size_t count, loff_t *ppos)
 565{
 566        struct ieee80211_sta *sta = file->private_data;
 567        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 568        struct ath10k *ar = arsta->arvif->ar;
 569        struct ath10k_sta_tid_stats *stats = arsta->tid_stats;
 570        size_t len = 0, buf_len = 1048 * IEEE80211_NUM_TIDS;
 571        char *buf;
 572        int i, j;
 573        ssize_t ret;
 574
 575        buf = kzalloc(buf_len, GFP_KERNEL);
 576        if (!buf)
 577                return -ENOMEM;
 578
 579        mutex_lock(&ar->conf_mutex);
 580
 581        spin_lock_bh(&ar->data_lock);
 582
 583        len += scnprintf(buf + len, buf_len - len,
 584                         "\n\t\tDriver Rx pkt stats per tid, ([tid] count)\n");
 585        len += scnprintf(buf + len, buf_len - len,
 586                         "\t\t------------------------------------------\n");
 587        len += scnprintf(buf + len, buf_len - len, "MSDUs from FW\t\t\t");
 588        PRINT_TID_STATS(rx_pkt_from_fw, "\t\t\t\t");
 589
 590        len += scnprintf(buf + len, buf_len - len, "MSDUs unchained\t\t\t");
 591        PRINT_TID_STATS(rx_pkt_unchained, "\t\t\t\t");
 592
 593        len += scnprintf(buf + len, buf_len - len,
 594                         "MSDUs locally dropped:chained\t");
 595        PRINT_TID_STATS(rx_pkt_drop_chained, "\t\t\t\t");
 596
 597        len += scnprintf(buf + len, buf_len - len,
 598                         "MSDUs locally dropped:filtered\t");
 599        PRINT_TID_STATS(rx_pkt_drop_filter, "\t\t\t\t");
 600
 601        len += scnprintf(buf + len, buf_len - len,
 602                         "MSDUs queued for mac80211\t");
 603        PRINT_TID_STATS(rx_pkt_queued_for_mac, "\t\t\t\t");
 604
 605        for (i = 0; i < ATH10K_PKT_RX_ERR_MAX; i++) {
 606                len += scnprintf(buf + len, buf_len - len,
 607                                 "MSDUs with error:%s\t", get_err_str(i));
 608                PRINT_TID_STATS(rx_pkt_err[i], "\t\t\t\t");
 609        }
 610
 611        len += scnprintf(buf + len, buf_len - len, "\n");
 612        for (i = 0; i < ATH10K_AMPDU_SUBFRM_NUM_MAX; i++) {
 613                len += scnprintf(buf + len, buf_len - len,
 614                                 "A-MPDU num subframes %s\t",
 615                                 get_num_ampdu_subfrm_str(i));
 616                PRINT_TID_STATS(rx_pkt_ampdu[i], "\t\t\t\t");
 617        }
 618
 619        len += scnprintf(buf + len, buf_len - len, "\n");
 620        for (i = 0; i < ATH10K_AMSDU_SUBFRM_NUM_MAX; i++) {
 621                len += scnprintf(buf + len, buf_len - len,
 622                                 "A-MSDU num subframes %s\t\t",
 623                                 get_num_amsdu_subfrm_str(i));
 624                PRINT_TID_STATS(rx_pkt_amsdu[i], "\t\t\t\t");
 625        }
 626
 627        spin_unlock_bh(&ar->data_lock);
 628
 629        ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 630
 631        kfree(buf);
 632
 633        mutex_unlock(&ar->conf_mutex);
 634
 635        return ret;
 636}
 637
 638static const struct file_operations fops_tid_stats_dump = {
 639        .open = simple_open,
 640        .read = ath10k_dbg_sta_read_tid_stats,
 641        .owner = THIS_MODULE,
 642        .llseek = default_llseek,
 643};
 644
 645static ssize_t ath10k_dbg_sta_dump_tx_stats(struct file *file,
 646                                            char __user *user_buf,
 647                                            size_t count, loff_t *ppos)
 648{
 649        struct ieee80211_sta *sta = file->private_data;
 650        struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
 651        struct ath10k *ar = arsta->arvif->ar;
 652        struct ath10k_htt_data_stats *stats;
 653        const char *str_name[ATH10K_STATS_TYPE_MAX] = {"succ", "fail",
 654                                                       "retry", "ampdu"};
 655        const char *str[ATH10K_COUNTER_TYPE_MAX] = {"bytes", "packets"};
 656        int len = 0, i, j, k, retval = 0;
 657        const int size = 16 * 4096;
 658        char *buf;
 659
 660        buf = kzalloc(size, GFP_KERNEL);
 661        if (!buf)
 662                return -ENOMEM;
 663
 664        mutex_lock(&ar->conf_mutex);
 665
 666        if (!arsta->tx_stats) {
 667                ath10k_warn(ar, "failed to get tx stats");
 668                mutex_unlock(&ar->conf_mutex);
 669                kfree(buf);
 670                return 0;
 671        }
 672
 673        spin_lock_bh(&ar->data_lock);
 674        for (k = 0; k < ATH10K_STATS_TYPE_MAX; k++) {
 675                for (j = 0; j < ATH10K_COUNTER_TYPE_MAX; j++) {
 676                        stats = &arsta->tx_stats->stats[k];
 677                        len += scnprintf(buf + len, size - len, "%s_%s\n",
 678                                         str_name[k],
 679                                         str[j]);
 680                        len += scnprintf(buf + len, size - len,
 681                                         " VHT MCS %s\n",
 682                                         str[j]);
 683                        for (i = 0; i < ATH10K_VHT_MCS_NUM; i++)
 684                                len += scnprintf(buf + len, size - len,
 685                                                 "  %llu ",
 686                                                 stats->vht[j][i]);
 687                        len += scnprintf(buf + len, size - len, "\n");
 688                        len += scnprintf(buf + len, size - len, " HT MCS %s\n",
 689                                         str[j]);
 690                        for (i = 0; i < ATH10K_HT_MCS_NUM; i++)
 691                                len += scnprintf(buf + len, size - len,
 692                                                 "  %llu ", stats->ht[j][i]);
 693                        len += scnprintf(buf + len, size - len, "\n");
 694                        len += scnprintf(buf + len, size - len,
 695                                        " BW %s (20,5,10,40,80,160 MHz)\n", str[j]);
 696                        len += scnprintf(buf + len, size - len,
 697                                         "  %llu %llu %llu %llu %llu %llu\n",
 698                                         stats->bw[j][0], stats->bw[j][1],
 699                                         stats->bw[j][2], stats->bw[j][3],
 700                                         stats->bw[j][4], stats->bw[j][5]);
 701                        len += scnprintf(buf + len, size - len,
 702                                         " NSS %s (1x1,2x2,3x3,4x4)\n", str[j]);
 703                        len += scnprintf(buf + len, size - len,
 704                                         "  %llu %llu %llu %llu\n",
 705                                         stats->nss[j][0], stats->nss[j][1],
 706                                         stats->nss[j][2], stats->nss[j][3]);
 707                        len += scnprintf(buf + len, size - len,
 708                                         " GI %s (LGI,SGI)\n",
 709                                         str[j]);
 710                        len += scnprintf(buf + len, size - len, "  %llu %llu\n",
 711                                         stats->gi[j][0], stats->gi[j][1]);
 712                        len += scnprintf(buf + len, size - len,
 713                                         " legacy rate %s (1,2 ... Mbps)\n  ",
 714                                         str[j]);
 715                        for (i = 0; i < ATH10K_LEGACY_NUM; i++)
 716                                len += scnprintf(buf + len, size - len, "%llu ",
 717                                                 stats->legacy[j][i]);
 718                        len += scnprintf(buf + len, size - len, "\n");
 719                        len += scnprintf(buf + len, size - len,
 720                                         " Rate table %s (1,2 ... Mbps)\n  ",
 721                                         str[j]);
 722                        for (i = 0; i < ATH10K_RATE_TABLE_NUM; i++) {
 723                                len += scnprintf(buf + len, size - len, "%llu ",
 724                                                 stats->rate_table[j][i]);
 725                                if (!((i + 1) % 8))
 726                                        len +=
 727                                        scnprintf(buf + len, size - len, "\n  ");
 728                        }
 729                }
 730        }
 731
 732        len += scnprintf(buf + len, size - len,
 733                         "\nTX duration\n %llu usecs\n",
 734                         arsta->tx_stats->tx_duration);
 735        len += scnprintf(buf + len, size - len,
 736                        "BA fails\n %llu\n", arsta->tx_stats->ba_fails);
 737        len += scnprintf(buf + len, size - len,
 738                        "ack fails\n %llu\n", arsta->tx_stats->ack_fails);
 739        spin_unlock_bh(&ar->data_lock);
 740
 741        if (len > size)
 742                len = size;
 743        retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 744        kfree(buf);
 745
 746        mutex_unlock(&ar->conf_mutex);
 747        return retval;
 748}
 749
 750static const struct file_operations fops_tx_stats = {
 751        .read = ath10k_dbg_sta_dump_tx_stats,
 752        .open = simple_open,
 753        .owner = THIS_MODULE,
 754        .llseek = default_llseek,
 755};
 756
 757void ath10k_sta_add_debugfs(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 758                            struct ieee80211_sta *sta, struct dentry *dir)
 759{
 760        struct ath10k *ar = hw->priv;
 761
 762        debugfs_create_file("aggr_mode", 0644, dir, sta, &fops_aggr_mode);
 763        debugfs_create_file("addba", 0200, dir, sta, &fops_addba);
 764        debugfs_create_file("addba_resp", 0200, dir, sta, &fops_addba_resp);
 765        debugfs_create_file("delba", 0200, dir, sta, &fops_delba);
 766        debugfs_create_file("peer_debug_trigger", 0600, dir, sta,
 767                            &fops_peer_debug_trigger);
 768        debugfs_create_file("dump_tid_stats", 0400, dir, sta,
 769                            &fops_tid_stats_dump);
 770
 771        if (ath10k_peer_stats_enabled(ar) &&
 772            ath10k_debug_is_extd_tx_stats_enabled(ar))
 773                debugfs_create_file("tx_stats", 0400, dir, sta,
 774                                    &fops_tx_stats);
 775        debugfs_create_file("peer_ps_state", 0400, dir, sta,
 776                            &fops_peer_ps_state);
 777}
 778