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 
12 static 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 
28 static 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 
48 void 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 
73 out:
74 	spin_unlock_bh(&ar->data_lock);
75 	rcu_read_unlock();
76 }
77 
78 void 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 
124 exit:
125 	rcu_read_unlock();
126 }
127 
128 static 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 
147 static 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 
166 void 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 
175 static 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 
194 static 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;
224 out:
225 	mutex_unlock(&ar->conf_mutex);
226 	return ret;
227 }
228 
229 static 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 
237 static 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;
276 out:
277 	mutex_unlock(&ar->conf_mutex);
278 	return ret;
279 }
280 
281 static 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 
288 static 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;
326 out:
327 	mutex_unlock(&ar->conf_mutex);
328 	return ret;
329 }
330 
331 static 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 
338 static 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;
377 out:
378 	mutex_unlock(&ar->conf_mutex);
379 	return ret;
380 }
381 
382 static 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 
389 static 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 
408 static ssize_t
409 ath10k_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 					ar->wmi.peer_param->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 	}
439 out:
440 	mutex_unlock(&ar->conf_mutex);
441 	return count;
442 }
443 
444 static 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 
452 static 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 
472 static 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 
479 static 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 
497 static 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 
521 static 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 
562 static 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 
638 static 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 
645 static 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 
750 static 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 
757 void 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