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