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 "debugfs_sta.h"
9 #include "core.h"
10 #include "peer.h"
11 #include "debug.h"
12 #include "dp_tx.h"
13 #include "debugfs_htt_stats.h"
14
ath11k_debugfs_sta_add_tx_stats(struct ath11k_sta * arsta,struct ath11k_per_peer_tx_stats * peer_stats,u8 legacy_rate_idx)15 void ath11k_debugfs_sta_add_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
ath11k_debugfs_sta_update_txcompl(struct ath11k * ar,struct sk_buff * msdu,struct hal_tx_status * ts)128 void ath11k_debugfs_sta_update_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_debugfs_sta_add_tx_stats(arsta, peer_stats, rate_idx);
204
205 err_out:
206 spin_unlock_bh(&ab->base_lock);
207 rcu_read_unlock();
208 }
209
ath11k_dbg_sta_dump_tx_stats(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)210 static ssize_t ath11k_dbg_sta_dump_tx_stats(struct file *file,
211 char __user *user_buf,
212 size_t count, loff_t *ppos)
213 {
214 struct ieee80211_sta *sta = file->private_data;
215 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
216 struct ath11k *ar = arsta->arvif->ar;
217 struct ath11k_htt_data_stats *stats;
218 static const char *str_name[ATH11K_STATS_TYPE_MAX] = {"succ", "fail",
219 "retry", "ampdu"};
220 static const char *str[ATH11K_COUNTER_TYPE_MAX] = {"bytes", "packets"};
221 int len = 0, i, j, k, retval = 0;
222 const int size = 2 * 4096;
223 char *buf;
224
225 if (!arsta->tx_stats)
226 return -ENOENT;
227
228 buf = kzalloc(size, GFP_KERNEL);
229 if (!buf)
230 return -ENOMEM;
231
232 mutex_lock(&ar->conf_mutex);
233
234 spin_lock_bh(&ar->data_lock);
235 for (k = 0; k < ATH11K_STATS_TYPE_MAX; k++) {
236 for (j = 0; j < ATH11K_COUNTER_TYPE_MAX; j++) {
237 stats = &arsta->tx_stats->stats[k];
238 len += scnprintf(buf + len, size - len, "%s_%s\n",
239 str_name[k],
240 str[j]);
241 len += scnprintf(buf + len, size - len,
242 " HE MCS %s\n",
243 str[j]);
244 for (i = 0; i < ATH11K_HE_MCS_NUM; i++)
245 len += scnprintf(buf + len, size - len,
246 " %llu ",
247 stats->he[j][i]);
248 len += scnprintf(buf + len, size - len, "\n");
249 len += scnprintf(buf + len, size - len,
250 " VHT MCS %s\n",
251 str[j]);
252 for (i = 0; i < ATH11K_VHT_MCS_NUM; i++)
253 len += scnprintf(buf + len, size - len,
254 " %llu ",
255 stats->vht[j][i]);
256 len += scnprintf(buf + len, size - len, "\n");
257 len += scnprintf(buf + len, size - len, " HT MCS %s\n",
258 str[j]);
259 for (i = 0; i < ATH11K_HT_MCS_NUM; i++)
260 len += scnprintf(buf + len, size - len,
261 " %llu ", stats->ht[j][i]);
262 len += scnprintf(buf + len, size - len, "\n");
263 len += scnprintf(buf + len, size - len,
264 " BW %s (20,40,80,160 MHz)\n", str[j]);
265 len += scnprintf(buf + len, size - len,
266 " %llu %llu %llu %llu\n",
267 stats->bw[j][0], stats->bw[j][1],
268 stats->bw[j][2], stats->bw[j][3]);
269 len += scnprintf(buf + len, size - len,
270 " NSS %s (1x1,2x2,3x3,4x4)\n", str[j]);
271 len += scnprintf(buf + len, size - len,
272 " %llu %llu %llu %llu\n",
273 stats->nss[j][0], stats->nss[j][1],
274 stats->nss[j][2], stats->nss[j][3]);
275 len += scnprintf(buf + len, size - len,
276 " GI %s (0.4us,0.8us,1.6us,3.2us)\n",
277 str[j]);
278 len += scnprintf(buf + len, size - len,
279 " %llu %llu %llu %llu\n",
280 stats->gi[j][0], stats->gi[j][1],
281 stats->gi[j][2], stats->gi[j][3]);
282 len += scnprintf(buf + len, size - len,
283 " legacy rate %s (1,2 ... Mbps)\n ",
284 str[j]);
285 for (i = 0; i < ATH11K_LEGACY_NUM; i++)
286 len += scnprintf(buf + len, size - len, "%llu ",
287 stats->legacy[j][i]);
288 len += scnprintf(buf + len, size - len, "\n");
289 }
290 }
291
292 len += scnprintf(buf + len, size - len,
293 "\nTX duration\n %llu usecs\n",
294 arsta->tx_stats->tx_duration);
295 len += scnprintf(buf + len, size - len,
296 "BA fails\n %llu\n", arsta->tx_stats->ba_fails);
297 len += scnprintf(buf + len, size - len,
298 "ack fails\n %llu\n", arsta->tx_stats->ack_fails);
299 spin_unlock_bh(&ar->data_lock);
300
301 if (len > size)
302 len = size;
303 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
304 kfree(buf);
305
306 mutex_unlock(&ar->conf_mutex);
307 return retval;
308 }
309
310 static const struct file_operations fops_tx_stats = {
311 .read = ath11k_dbg_sta_dump_tx_stats,
312 .open = simple_open,
313 .owner = THIS_MODULE,
314 .llseek = default_llseek,
315 };
316
ath11k_dbg_sta_dump_rx_stats(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)317 static ssize_t ath11k_dbg_sta_dump_rx_stats(struct file *file,
318 char __user *user_buf,
319 size_t count, loff_t *ppos)
320 {
321 struct ieee80211_sta *sta = file->private_data;
322 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
323 struct ath11k *ar = arsta->arvif->ar;
324 struct ath11k_rx_peer_stats *rx_stats = arsta->rx_stats;
325 int len = 0, i, retval = 0;
326 const int size = 4096;
327 char *buf;
328
329 if (!rx_stats)
330 return -ENOENT;
331
332 buf = kzalloc(size, GFP_KERNEL);
333 if (!buf)
334 return -ENOMEM;
335
336 mutex_lock(&ar->conf_mutex);
337 spin_lock_bh(&ar->ab->base_lock);
338
339 len += scnprintf(buf + len, size - len, "RX peer stats:\n");
340 len += scnprintf(buf + len, size - len, "Num of MSDUs: %llu\n",
341 rx_stats->num_msdu);
342 len += scnprintf(buf + len, size - len, "Num of MSDUs with TCP L4: %llu\n",
343 rx_stats->tcp_msdu_count);
344 len += scnprintf(buf + len, size - len, "Num of MSDUs with UDP L4: %llu\n",
345 rx_stats->udp_msdu_count);
346 len += scnprintf(buf + len, size - len, "Num of MSDUs part of AMPDU: %llu\n",
347 rx_stats->ampdu_msdu_count);
348 len += scnprintf(buf + len, size - len, "Num of MSDUs not part of AMPDU: %llu\n",
349 rx_stats->non_ampdu_msdu_count);
350 len += scnprintf(buf + len, size - len, "Num of MSDUs using STBC: %llu\n",
351 rx_stats->stbc_count);
352 len += scnprintf(buf + len, size - len, "Num of MSDUs beamformed: %llu\n",
353 rx_stats->beamformed_count);
354 len += scnprintf(buf + len, size - len, "Num of MPDUs with FCS ok: %llu\n",
355 rx_stats->num_mpdu_fcs_ok);
356 len += scnprintf(buf + len, size - len, "Num of MPDUs with FCS error: %llu\n",
357 rx_stats->num_mpdu_fcs_err);
358 len += scnprintf(buf + len, size - len,
359 "GI: 0.8us %llu 0.4us %llu 1.6us %llu 3.2us %llu\n",
360 rx_stats->gi_count[0], rx_stats->gi_count[1],
361 rx_stats->gi_count[2], rx_stats->gi_count[3]);
362 len += scnprintf(buf + len, size - len,
363 "BW: 20Mhz %llu 40Mhz %llu 80Mhz %llu 160Mhz %llu\n",
364 rx_stats->bw_count[0], rx_stats->bw_count[1],
365 rx_stats->bw_count[2], rx_stats->bw_count[3]);
366 len += scnprintf(buf + len, size - len, "BCC %llu LDPC %llu\n",
367 rx_stats->coding_count[0], rx_stats->coding_count[1]);
368 len += scnprintf(buf + len, size - len,
369 "preamble: 11A %llu 11B %llu 11N %llu 11AC %llu 11AX %llu\n",
370 rx_stats->pream_cnt[0], rx_stats->pream_cnt[1],
371 rx_stats->pream_cnt[2], rx_stats->pream_cnt[3],
372 rx_stats->pream_cnt[4]);
373 len += scnprintf(buf + len, size - len,
374 "reception type: SU %llu MU_MIMO %llu MU_OFDMA %llu MU_OFDMA_MIMO %llu\n",
375 rx_stats->reception_type[0], rx_stats->reception_type[1],
376 rx_stats->reception_type[2], rx_stats->reception_type[3]);
377 len += scnprintf(buf + len, size - len, "TID(0-15) Legacy TID(16):");
378 for (i = 0; i <= IEEE80211_NUM_TIDS; i++)
379 len += scnprintf(buf + len, size - len, "%llu ", rx_stats->tid_count[i]);
380 len += scnprintf(buf + len, size - len, "\nMCS(0-11) Legacy MCS(12):");
381 for (i = 0; i < HAL_RX_MAX_MCS + 1; i++)
382 len += scnprintf(buf + len, size - len, "%llu ", rx_stats->mcs_count[i]);
383 len += scnprintf(buf + len, size - len, "\nNSS(1-8):");
384 for (i = 0; i < HAL_RX_MAX_NSS; i++)
385 len += scnprintf(buf + len, size - len, "%llu ", rx_stats->nss_count[i]);
386 len += scnprintf(buf + len, size - len, "\nRX Duration:%llu ",
387 rx_stats->rx_duration);
388 len += scnprintf(buf + len, size - len,
389 "\nDCM: %llu\nRU: 26 %llu 52: %llu 106: %llu 242: %llu 484: %llu 996: %llu\n",
390 rx_stats->dcm_count, rx_stats->ru_alloc_cnt[0],
391 rx_stats->ru_alloc_cnt[1], rx_stats->ru_alloc_cnt[2],
392 rx_stats->ru_alloc_cnt[3], rx_stats->ru_alloc_cnt[4],
393 rx_stats->ru_alloc_cnt[5]);
394
395 len += scnprintf(buf + len, size - len, "\n");
396
397 spin_unlock_bh(&ar->ab->base_lock);
398
399 if (len > size)
400 len = size;
401 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
402 kfree(buf);
403
404 mutex_unlock(&ar->conf_mutex);
405 return retval;
406 }
407
408 static const struct file_operations fops_rx_stats = {
409 .read = ath11k_dbg_sta_dump_rx_stats,
410 .open = simple_open,
411 .owner = THIS_MODULE,
412 .llseek = default_llseek,
413 };
414
415 static int
ath11k_dbg_sta_open_htt_peer_stats(struct inode * inode,struct file * file)416 ath11k_dbg_sta_open_htt_peer_stats(struct inode *inode, struct file *file)
417 {
418 struct ieee80211_sta *sta = inode->i_private;
419 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
420 struct ath11k *ar = arsta->arvif->ar;
421 struct debug_htt_stats_req *stats_req;
422 int type = ar->debug.htt_stats.type;
423 int ret;
424
425 if ((type != ATH11K_DBG_HTT_EXT_STATS_PEER_INFO &&
426 type != ATH11K_DBG_HTT_EXT_STATS_PEER_CTRL_PATH_TXRX_STATS) ||
427 type == ATH11K_DBG_HTT_EXT_STATS_RESET)
428 return -EPERM;
429
430 stats_req = vzalloc(sizeof(*stats_req) + ATH11K_HTT_STATS_BUF_SIZE);
431 if (!stats_req)
432 return -ENOMEM;
433
434 mutex_lock(&ar->conf_mutex);
435 ar->debug.htt_stats.stats_req = stats_req;
436 stats_req->type = type;
437 memcpy(stats_req->peer_addr, sta->addr, ETH_ALEN);
438 ret = ath11k_debugfs_htt_stats_req(ar);
439 mutex_unlock(&ar->conf_mutex);
440 if (ret < 0)
441 goto out;
442
443 file->private_data = stats_req;
444 return 0;
445 out:
446 vfree(stats_req);
447 ar->debug.htt_stats.stats_req = NULL;
448 return ret;
449 }
450
451 static int
ath11k_dbg_sta_release_htt_peer_stats(struct inode * inode,struct file * file)452 ath11k_dbg_sta_release_htt_peer_stats(struct inode *inode, struct file *file)
453 {
454 struct ieee80211_sta *sta = inode->i_private;
455 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
456 struct ath11k *ar = arsta->arvif->ar;
457
458 mutex_lock(&ar->conf_mutex);
459 vfree(file->private_data);
460 ar->debug.htt_stats.stats_req = NULL;
461 mutex_unlock(&ar->conf_mutex);
462
463 return 0;
464 }
465
ath11k_dbg_sta_read_htt_peer_stats(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)466 static ssize_t ath11k_dbg_sta_read_htt_peer_stats(struct file *file,
467 char __user *user_buf,
468 size_t count, loff_t *ppos)
469 {
470 struct debug_htt_stats_req *stats_req = file->private_data;
471 char *buf;
472 u32 length = 0;
473
474 buf = stats_req->buf;
475 length = min_t(u32, stats_req->buf_len, ATH11K_HTT_STATS_BUF_SIZE);
476 return simple_read_from_buffer(user_buf, count, ppos, buf, length);
477 }
478
479 static const struct file_operations fops_htt_peer_stats = {
480 .open = ath11k_dbg_sta_open_htt_peer_stats,
481 .release = ath11k_dbg_sta_release_htt_peer_stats,
482 .read = ath11k_dbg_sta_read_htt_peer_stats,
483 .owner = THIS_MODULE,
484 .llseek = default_llseek,
485 };
486
ath11k_dbg_sta_write_peer_pktlog(struct file * file,const char __user * buf,size_t count,loff_t * ppos)487 static ssize_t ath11k_dbg_sta_write_peer_pktlog(struct file *file,
488 const char __user *buf,
489 size_t count, loff_t *ppos)
490 {
491 struct ieee80211_sta *sta = file->private_data;
492 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
493 struct ath11k *ar = arsta->arvif->ar;
494 int ret, enable;
495
496 mutex_lock(&ar->conf_mutex);
497
498 if (ar->state != ATH11K_STATE_ON) {
499 ret = -ENETDOWN;
500 goto out;
501 }
502
503 ret = kstrtoint_from_user(buf, count, 0, &enable);
504 if (ret)
505 goto out;
506
507 ar->debug.pktlog_peer_valid = enable;
508 memcpy(ar->debug.pktlog_peer_addr, sta->addr, ETH_ALEN);
509
510 /* Send peer based pktlog enable/disable */
511 ret = ath11k_wmi_pdev_peer_pktlog_filter(ar, sta->addr, enable);
512 if (ret) {
513 ath11k_warn(ar->ab, "failed to set peer pktlog filter %pM: %d\n",
514 sta->addr, ret);
515 goto out;
516 }
517
518 ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "peer pktlog filter set to %d\n",
519 enable);
520 ret = count;
521
522 out:
523 mutex_unlock(&ar->conf_mutex);
524 return ret;
525 }
526
ath11k_dbg_sta_read_peer_pktlog(struct file * file,char __user * ubuf,size_t count,loff_t * ppos)527 static ssize_t ath11k_dbg_sta_read_peer_pktlog(struct file *file,
528 char __user *ubuf,
529 size_t count, loff_t *ppos)
530 {
531 struct ieee80211_sta *sta = file->private_data;
532 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
533 struct ath11k *ar = arsta->arvif->ar;
534 char buf[32] = {0};
535 int len;
536
537 mutex_lock(&ar->conf_mutex);
538 len = scnprintf(buf, sizeof(buf), "%08x %pM\n",
539 ar->debug.pktlog_peer_valid,
540 ar->debug.pktlog_peer_addr);
541 mutex_unlock(&ar->conf_mutex);
542
543 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
544 }
545
546 static const struct file_operations fops_peer_pktlog = {
547 .write = ath11k_dbg_sta_write_peer_pktlog,
548 .read = ath11k_dbg_sta_read_peer_pktlog,
549 .open = simple_open,
550 .owner = THIS_MODULE,
551 .llseek = default_llseek,
552 };
553
ath11k_dbg_sta_write_delba(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)554 static ssize_t ath11k_dbg_sta_write_delba(struct file *file,
555 const char __user *user_buf,
556 size_t count, loff_t *ppos)
557 {
558 struct ieee80211_sta *sta = file->private_data;
559 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
560 struct ath11k *ar = arsta->arvif->ar;
561 u32 tid, initiator, reason;
562 int ret;
563 char buf[64] = {0};
564
565 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
566 user_buf, count);
567 if (ret <= 0)
568 return ret;
569
570 ret = sscanf(buf, "%u %u %u", &tid, &initiator, &reason);
571 if (ret != 3)
572 return -EINVAL;
573
574 /* Valid TID values are 0 through 15 */
575 if (tid > HAL_DESC_REO_NON_QOS_TID - 1)
576 return -EINVAL;
577
578 mutex_lock(&ar->conf_mutex);
579 if (ar->state != ATH11K_STATE_ON ||
580 arsta->aggr_mode != ATH11K_DBG_AGGR_MODE_MANUAL) {
581 ret = count;
582 goto out;
583 }
584
585 ret = ath11k_wmi_delba_send(ar, arsta->arvif->vdev_id, sta->addr,
586 tid, initiator, reason);
587 if (ret) {
588 ath11k_warn(ar->ab, "failed to send delba: vdev_id %u peer %pM tid %u initiator %u reason %u\n",
589 arsta->arvif->vdev_id, sta->addr, tid, initiator,
590 reason);
591 }
592 ret = count;
593 out:
594 mutex_unlock(&ar->conf_mutex);
595 return ret;
596 }
597
598 static const struct file_operations fops_delba = {
599 .write = ath11k_dbg_sta_write_delba,
600 .open = simple_open,
601 .owner = THIS_MODULE,
602 .llseek = default_llseek,
603 };
604
ath11k_dbg_sta_write_addba_resp(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)605 static ssize_t ath11k_dbg_sta_write_addba_resp(struct file *file,
606 const char __user *user_buf,
607 size_t count, loff_t *ppos)
608 {
609 struct ieee80211_sta *sta = file->private_data;
610 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
611 struct ath11k *ar = arsta->arvif->ar;
612 u32 tid, status;
613 int ret;
614 char buf[64] = {0};
615
616 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
617 user_buf, count);
618 if (ret <= 0)
619 return ret;
620
621 ret = sscanf(buf, "%u %u", &tid, &status);
622 if (ret != 2)
623 return -EINVAL;
624
625 /* Valid TID values are 0 through 15 */
626 if (tid > HAL_DESC_REO_NON_QOS_TID - 1)
627 return -EINVAL;
628
629 mutex_lock(&ar->conf_mutex);
630 if (ar->state != ATH11K_STATE_ON ||
631 arsta->aggr_mode != ATH11K_DBG_AGGR_MODE_MANUAL) {
632 ret = count;
633 goto out;
634 }
635
636 ret = ath11k_wmi_addba_set_resp(ar, arsta->arvif->vdev_id, sta->addr,
637 tid, status);
638 if (ret) {
639 ath11k_warn(ar->ab, "failed to send addba response: vdev_id %u peer %pM tid %u status%u\n",
640 arsta->arvif->vdev_id, sta->addr, tid, status);
641 }
642 ret = count;
643 out:
644 mutex_unlock(&ar->conf_mutex);
645 return ret;
646 }
647
648 static const struct file_operations fops_addba_resp = {
649 .write = ath11k_dbg_sta_write_addba_resp,
650 .open = simple_open,
651 .owner = THIS_MODULE,
652 .llseek = default_llseek,
653 };
654
ath11k_dbg_sta_write_addba(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)655 static ssize_t ath11k_dbg_sta_write_addba(struct file *file,
656 const char __user *user_buf,
657 size_t count, loff_t *ppos)
658 {
659 struct ieee80211_sta *sta = file->private_data;
660 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
661 struct ath11k *ar = arsta->arvif->ar;
662 u32 tid, buf_size;
663 int ret;
664 char buf[64] = {0};
665
666 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
667 user_buf, count);
668 if (ret <= 0)
669 return ret;
670
671 ret = sscanf(buf, "%u %u", &tid, &buf_size);
672 if (ret != 2)
673 return -EINVAL;
674
675 /* Valid TID values are 0 through 15 */
676 if (tid > HAL_DESC_REO_NON_QOS_TID - 1)
677 return -EINVAL;
678
679 mutex_lock(&ar->conf_mutex);
680 if (ar->state != ATH11K_STATE_ON ||
681 arsta->aggr_mode != ATH11K_DBG_AGGR_MODE_MANUAL) {
682 ret = count;
683 goto out;
684 }
685
686 ret = ath11k_wmi_addba_send(ar, arsta->arvif->vdev_id, sta->addr,
687 tid, buf_size);
688 if (ret) {
689 ath11k_warn(ar->ab, "failed to send addba request: vdev_id %u peer %pM tid %u buf_size %u\n",
690 arsta->arvif->vdev_id, sta->addr, tid, buf_size);
691 }
692
693 ret = count;
694 out:
695 mutex_unlock(&ar->conf_mutex);
696 return ret;
697 }
698
699 static const struct file_operations fops_addba = {
700 .write = ath11k_dbg_sta_write_addba,
701 .open = simple_open,
702 .owner = THIS_MODULE,
703 .llseek = default_llseek,
704 };
705
ath11k_dbg_sta_read_aggr_mode(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)706 static ssize_t ath11k_dbg_sta_read_aggr_mode(struct file *file,
707 char __user *user_buf,
708 size_t count, loff_t *ppos)
709 {
710 struct ieee80211_sta *sta = file->private_data;
711 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
712 struct ath11k *ar = arsta->arvif->ar;
713 char buf[64];
714 int len = 0;
715
716 mutex_lock(&ar->conf_mutex);
717 len = scnprintf(buf, sizeof(buf) - len,
718 "aggregation mode: %s\n\n%s\n%s\n",
719 (arsta->aggr_mode == ATH11K_DBG_AGGR_MODE_AUTO) ?
720 "auto" : "manual", "auto = 0", "manual = 1");
721 mutex_unlock(&ar->conf_mutex);
722
723 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
724 }
725
ath11k_dbg_sta_write_aggr_mode(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)726 static ssize_t ath11k_dbg_sta_write_aggr_mode(struct file *file,
727 const char __user *user_buf,
728 size_t count, loff_t *ppos)
729 {
730 struct ieee80211_sta *sta = file->private_data;
731 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
732 struct ath11k *ar = arsta->arvif->ar;
733 u32 aggr_mode;
734 int ret;
735
736 if (kstrtouint_from_user(user_buf, count, 0, &aggr_mode))
737 return -EINVAL;
738
739 if (aggr_mode >= ATH11K_DBG_AGGR_MODE_MAX)
740 return -EINVAL;
741
742 mutex_lock(&ar->conf_mutex);
743 if (ar->state != ATH11K_STATE_ON ||
744 aggr_mode == arsta->aggr_mode) {
745 ret = count;
746 goto out;
747 }
748
749 ret = ath11k_wmi_addba_clear_resp(ar, arsta->arvif->vdev_id, sta->addr);
750 if (ret) {
751 ath11k_warn(ar->ab, "failed to clear addba session ret: %d\n",
752 ret);
753 goto out;
754 }
755
756 arsta->aggr_mode = aggr_mode;
757 out:
758 mutex_unlock(&ar->conf_mutex);
759 return ret;
760 }
761
762 static const struct file_operations fops_aggr_mode = {
763 .read = ath11k_dbg_sta_read_aggr_mode,
764 .write = ath11k_dbg_sta_write_aggr_mode,
765 .open = simple_open,
766 .owner = THIS_MODULE,
767 .llseek = default_llseek,
768 };
769
770 static ssize_t
ath11k_write_htt_peer_stats_reset(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)771 ath11k_write_htt_peer_stats_reset(struct file *file,
772 const char __user *user_buf,
773 size_t count, loff_t *ppos)
774 {
775 struct ieee80211_sta *sta = file->private_data;
776 struct ath11k_sta *arsta = (struct ath11k_sta *)sta->drv_priv;
777 struct ath11k *ar = arsta->arvif->ar;
778 struct htt_ext_stats_cfg_params cfg_params = { 0 };
779 int ret;
780 u8 type;
781
782 ret = kstrtou8_from_user(user_buf, count, 0, &type);
783 if (ret)
784 return ret;
785
786 if (!type)
787 return ret;
788
789 mutex_lock(&ar->conf_mutex);
790 cfg_params.cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR;
791 cfg_params.cfg0 |= FIELD_PREP(GENMASK(15, 1),
792 HTT_PEER_STATS_REQ_MODE_FLUSH_TQM);
793
794 cfg_params.cfg1 = HTT_STAT_DEFAULT_PEER_REQ_TYPE;
795
796 cfg_params.cfg2 |= FIELD_PREP(GENMASK(7, 0), sta->addr[0]);
797 cfg_params.cfg2 |= FIELD_PREP(GENMASK(15, 8), sta->addr[1]);
798 cfg_params.cfg2 |= FIELD_PREP(GENMASK(23, 16), sta->addr[2]);
799 cfg_params.cfg2 |= FIELD_PREP(GENMASK(31, 24), sta->addr[3]);
800
801 cfg_params.cfg3 |= FIELD_PREP(GENMASK(7, 0), sta->addr[4]);
802 cfg_params.cfg3 |= FIELD_PREP(GENMASK(15, 8), sta->addr[5]);
803
804 cfg_params.cfg3 |= ATH11K_HTT_PEER_STATS_RESET;
805
806 ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar,
807 ATH11K_DBG_HTT_EXT_STATS_PEER_INFO,
808 &cfg_params,
809 0ULL);
810 if (ret) {
811 ath11k_warn(ar->ab, "failed to send htt peer stats request: %d\n", ret);
812 mutex_unlock(&ar->conf_mutex);
813 return ret;
814 }
815
816 mutex_unlock(&ar->conf_mutex);
817
818 ret = count;
819
820 return ret;
821 }
822
823 static const struct file_operations fops_htt_peer_stats_reset = {
824 .write = ath11k_write_htt_peer_stats_reset,
825 .open = simple_open,
826 .owner = THIS_MODULE,
827 .llseek = default_llseek,
828 };
829
ath11k_debugfs_sta_op_add(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct dentry * dir)830 void ath11k_debugfs_sta_op_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
831 struct ieee80211_sta *sta, struct dentry *dir)
832 {
833 struct ath11k *ar = hw->priv;
834
835 if (ath11k_debugfs_is_extd_tx_stats_enabled(ar))
836 debugfs_create_file("tx_stats", 0400, dir, sta,
837 &fops_tx_stats);
838 if (ath11k_debugfs_is_extd_rx_stats_enabled(ar))
839 debugfs_create_file("rx_stats", 0400, dir, sta,
840 &fops_rx_stats);
841
842 debugfs_create_file("htt_peer_stats", 0400, dir, sta,
843 &fops_htt_peer_stats);
844
845 debugfs_create_file("peer_pktlog", 0644, dir, sta,
846 &fops_peer_pktlog);
847
848 debugfs_create_file("aggr_mode", 0644, dir, sta, &fops_aggr_mode);
849 debugfs_create_file("addba", 0200, dir, sta, &fops_addba);
850 debugfs_create_file("addba_resp", 0200, dir, sta, &fops_addba_resp);
851 debugfs_create_file("delba", 0200, dir, sta, &fops_delba);
852
853 if (test_bit(WMI_TLV_SERVICE_PER_PEER_HTT_STATS_RESET,
854 ar->ab->wmi_ab.svc_map))
855 debugfs_create_file("htt_peer_stats_reset", 0600, dir, sta,
856 &fops_htt_peer_stats_reset);
857 }
858