xref: /openbmc/linux/net/mac80211/debugfs_sta.c (revision e7253313)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright 2003-2005	Devicescape Software, Inc.
4  * Copyright (c) 2006	Jiri Benc <jbenc@suse.cz>
5  * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
6  * Copyright 2013-2014  Intel Mobile Communications GmbH
7  * Copyright(c) 2016 Intel Deutschland GmbH
8  * Copyright (C) 2018 - 2019 Intel Corporation
9  */
10 
11 #include <linux/debugfs.h>
12 #include <linux/ieee80211.h>
13 #include "ieee80211_i.h"
14 #include "debugfs.h"
15 #include "debugfs_sta.h"
16 #include "sta_info.h"
17 #include "driver-ops.h"
18 
19 /* sta attributtes */
20 
21 #define STA_READ(name, field, format_string)				\
22 static ssize_t sta_ ##name## _read(struct file *file,			\
23 				   char __user *userbuf,		\
24 				   size_t count, loff_t *ppos)		\
25 {									\
26 	struct sta_info *sta = file->private_data;			\
27 	return mac80211_format_buffer(userbuf, count, ppos, 		\
28 				      format_string, sta->field);	\
29 }
30 #define STA_READ_D(name, field) STA_READ(name, field, "%d\n")
31 
32 #define STA_OPS(name)							\
33 static const struct file_operations sta_ ##name## _ops = {		\
34 	.read = sta_##name##_read,					\
35 	.open = simple_open,						\
36 	.llseek = generic_file_llseek,					\
37 }
38 
39 #define STA_OPS_RW(name)						\
40 static const struct file_operations sta_ ##name## _ops = {		\
41 	.read = sta_##name##_read,					\
42 	.write = sta_##name##_write,					\
43 	.open = simple_open,						\
44 	.llseek = generic_file_llseek,					\
45 }
46 
47 #define STA_FILE(name, field, format)					\
48 		STA_READ_##format(name, field)				\
49 		STA_OPS(name)
50 
51 STA_FILE(aid, sta.aid, D);
52 
53 static const char * const sta_flag_names[] = {
54 #define FLAG(F) [WLAN_STA_##F] = #F
55 	FLAG(AUTH),
56 	FLAG(ASSOC),
57 	FLAG(PS_STA),
58 	FLAG(AUTHORIZED),
59 	FLAG(SHORT_PREAMBLE),
60 	FLAG(WDS),
61 	FLAG(CLEAR_PS_FILT),
62 	FLAG(MFP),
63 	FLAG(BLOCK_BA),
64 	FLAG(PS_DRIVER),
65 	FLAG(PSPOLL),
66 	FLAG(TDLS_PEER),
67 	FLAG(TDLS_PEER_AUTH),
68 	FLAG(TDLS_INITIATOR),
69 	FLAG(TDLS_CHAN_SWITCH),
70 	FLAG(TDLS_OFF_CHANNEL),
71 	FLAG(TDLS_WIDER_BW),
72 	FLAG(UAPSD),
73 	FLAG(SP),
74 	FLAG(4ADDR_EVENT),
75 	FLAG(INSERTED),
76 	FLAG(RATE_CONTROL),
77 	FLAG(TOFFSET_KNOWN),
78 	FLAG(MPSP_OWNER),
79 	FLAG(MPSP_RECIPIENT),
80 	FLAG(PS_DELIVER),
81 #undef FLAG
82 };
83 
84 static ssize_t sta_flags_read(struct file *file, char __user *userbuf,
85 			      size_t count, loff_t *ppos)
86 {
87 	char buf[16 * NUM_WLAN_STA_FLAGS], *pos = buf;
88 	char *end = buf + sizeof(buf) - 1;
89 	struct sta_info *sta = file->private_data;
90 	unsigned int flg;
91 
92 	BUILD_BUG_ON(ARRAY_SIZE(sta_flag_names) != NUM_WLAN_STA_FLAGS);
93 
94 	for (flg = 0; flg < NUM_WLAN_STA_FLAGS; flg++) {
95 		if (test_sta_flag(sta, flg))
96 			pos += scnprintf(pos, end - pos, "%s\n",
97 					 sta_flag_names[flg]);
98 	}
99 
100 	return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
101 }
102 STA_OPS(flags);
103 
104 static ssize_t sta_num_ps_buf_frames_read(struct file *file,
105 					  char __user *userbuf,
106 					  size_t count, loff_t *ppos)
107 {
108 	struct sta_info *sta = file->private_data;
109 	char buf[17*IEEE80211_NUM_ACS], *p = buf;
110 	int ac;
111 
112 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
113 		p += scnprintf(p, sizeof(buf)+buf-p, "AC%d: %d\n", ac,
114 			       skb_queue_len(&sta->ps_tx_buf[ac]) +
115 			       skb_queue_len(&sta->tx_filtered[ac]));
116 	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
117 }
118 STA_OPS(num_ps_buf_frames);
119 
120 static ssize_t sta_last_seq_ctrl_read(struct file *file, char __user *userbuf,
121 				      size_t count, loff_t *ppos)
122 {
123 	char buf[15*IEEE80211_NUM_TIDS], *p = buf;
124 	int i;
125 	struct sta_info *sta = file->private_data;
126 	for (i = 0; i < IEEE80211_NUM_TIDS; i++)
127 		p += scnprintf(p, sizeof(buf)+buf-p, "%x ",
128 			       le16_to_cpu(sta->last_seq_ctrl[i]));
129 	p += scnprintf(p, sizeof(buf)+buf-p, "\n");
130 	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
131 }
132 STA_OPS(last_seq_ctrl);
133 
134 #define AQM_TXQ_ENTRY_LEN 130
135 
136 static ssize_t sta_aqm_read(struct file *file, char __user *userbuf,
137 			size_t count, loff_t *ppos)
138 {
139 	struct sta_info *sta = file->private_data;
140 	struct ieee80211_local *local = sta->local;
141 	size_t bufsz = AQM_TXQ_ENTRY_LEN * (IEEE80211_NUM_TIDS + 2);
142 	char *buf = kzalloc(bufsz, GFP_KERNEL), *p = buf;
143 	struct txq_info *txqi;
144 	ssize_t rv;
145 	int i;
146 
147 	if (!buf)
148 		return -ENOMEM;
149 
150 	spin_lock_bh(&local->fq.lock);
151 	rcu_read_lock();
152 
153 	p += scnprintf(p,
154 		       bufsz+buf-p,
155 		       "target %uus interval %uus ecn %s\n",
156 		       codel_time_to_us(sta->cparams.target),
157 		       codel_time_to_us(sta->cparams.interval),
158 		       sta->cparams.ecn ? "yes" : "no");
159 	p += scnprintf(p,
160 		       bufsz+buf-p,
161 		       "tid ac backlog-bytes backlog-packets new-flows drops marks overlimit collisions tx-bytes tx-packets flags\n");
162 
163 	for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
164 		if (!sta->sta.txq[i])
165 			continue;
166 		txqi = to_txq_info(sta->sta.txq[i]);
167 		p += scnprintf(p, bufsz+buf-p,
168 			       "%d %d %u %u %u %u %u %u %u %u %u 0x%lx(%s%s%s)\n",
169 			       txqi->txq.tid,
170 			       txqi->txq.ac,
171 			       txqi->tin.backlog_bytes,
172 			       txqi->tin.backlog_packets,
173 			       txqi->tin.flows,
174 			       txqi->cstats.drop_count,
175 			       txqi->cstats.ecn_mark,
176 			       txqi->tin.overlimit,
177 			       txqi->tin.collisions,
178 			       txqi->tin.tx_bytes,
179 			       txqi->tin.tx_packets,
180 			       txqi->flags,
181 			       test_bit(IEEE80211_TXQ_STOP, &txqi->flags) ? "STOP" : "RUN",
182 			       test_bit(IEEE80211_TXQ_AMPDU, &txqi->flags) ? " AMPDU" : "",
183 			       test_bit(IEEE80211_TXQ_NO_AMSDU, &txqi->flags) ? " NO-AMSDU" : "");
184 	}
185 
186 	rcu_read_unlock();
187 	spin_unlock_bh(&local->fq.lock);
188 
189 	rv = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
190 	kfree(buf);
191 	return rv;
192 }
193 STA_OPS(aqm);
194 
195 static ssize_t sta_airtime_read(struct file *file, char __user *userbuf,
196 				size_t count, loff_t *ppos)
197 {
198 	struct sta_info *sta = file->private_data;
199 	struct ieee80211_local *local = sta->sdata->local;
200 	size_t bufsz = 400;
201 	char *buf = kzalloc(bufsz, GFP_KERNEL), *p = buf;
202 	u64 rx_airtime = 0, tx_airtime = 0;
203 	s64 deficit[IEEE80211_NUM_ACS];
204 	ssize_t rv;
205 	int ac;
206 
207 	if (!buf)
208 		return -ENOMEM;
209 
210 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
211 		spin_lock_bh(&local->active_txq_lock[ac]);
212 		rx_airtime += sta->airtime[ac].rx_airtime;
213 		tx_airtime += sta->airtime[ac].tx_airtime;
214 		deficit[ac] = sta->airtime[ac].deficit;
215 		spin_unlock_bh(&local->active_txq_lock[ac]);
216 	}
217 
218 	p += scnprintf(p, bufsz + buf - p,
219 		"RX: %llu us\nTX: %llu us\nWeight: %u\n"
220 		"Deficit: VO: %lld us VI: %lld us BE: %lld us BK: %lld us\n",
221 		rx_airtime, tx_airtime, sta->airtime_weight,
222 		deficit[0], deficit[1], deficit[2], deficit[3]);
223 
224 	rv = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
225 	kfree(buf);
226 	return rv;
227 }
228 
229 static ssize_t sta_airtime_write(struct file *file, const char __user *userbuf,
230 				 size_t count, loff_t *ppos)
231 {
232 	struct sta_info *sta = file->private_data;
233 	struct ieee80211_local *local = sta->sdata->local;
234 	int ac;
235 
236 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
237 		spin_lock_bh(&local->active_txq_lock[ac]);
238 		sta->airtime[ac].rx_airtime = 0;
239 		sta->airtime[ac].tx_airtime = 0;
240 		sta->airtime[ac].deficit = sta->airtime_weight;
241 		spin_unlock_bh(&local->active_txq_lock[ac]);
242 	}
243 
244 	return count;
245 }
246 STA_OPS_RW(airtime);
247 
248 static ssize_t sta_aql_read(struct file *file, char __user *userbuf,
249 				size_t count, loff_t *ppos)
250 {
251 	struct sta_info *sta = file->private_data;
252 	struct ieee80211_local *local = sta->sdata->local;
253 	size_t bufsz = 400;
254 	char *buf = kzalloc(bufsz, GFP_KERNEL), *p = buf;
255 	u32 q_depth[IEEE80211_NUM_ACS];
256 	u32 q_limit_l[IEEE80211_NUM_ACS], q_limit_h[IEEE80211_NUM_ACS];
257 	ssize_t rv;
258 	int ac;
259 
260 	if (!buf)
261 		return -ENOMEM;
262 
263 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
264 		spin_lock_bh(&local->active_txq_lock[ac]);
265 		q_limit_l[ac] = sta->airtime[ac].aql_limit_low;
266 		q_limit_h[ac] = sta->airtime[ac].aql_limit_high;
267 		spin_unlock_bh(&local->active_txq_lock[ac]);
268 		q_depth[ac] = atomic_read(&sta->airtime[ac].aql_tx_pending);
269 	}
270 
271 	p += scnprintf(p, bufsz + buf - p,
272 		"Q depth: VO: %u us VI: %u us BE: %u us BK: %u us\n"
273 		"Q limit[low/high]: VO: %u/%u VI: %u/%u BE: %u/%u BK: %u/%u\n",
274 		q_depth[0], q_depth[1], q_depth[2], q_depth[3],
275 		q_limit_l[0], q_limit_h[0], q_limit_l[1], q_limit_h[1],
276 		q_limit_l[2], q_limit_h[2], q_limit_l[3], q_limit_h[3]),
277 
278 	rv = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
279 	kfree(buf);
280 	return rv;
281 }
282 
283 static ssize_t sta_aql_write(struct file *file, const char __user *userbuf,
284 				 size_t count, loff_t *ppos)
285 {
286 	struct sta_info *sta = file->private_data;
287 	u32 ac, q_limit_l, q_limit_h;
288 	char _buf[100] = {}, *buf = _buf;
289 
290 	if (count > sizeof(_buf))
291 		return -EINVAL;
292 
293 	if (copy_from_user(buf, userbuf, count))
294 		return -EFAULT;
295 
296 	buf[sizeof(_buf) - 1] = '\0';
297 	if (sscanf(buf, "limit %u %u %u", &ac, &q_limit_l, &q_limit_h)
298 	    != 3)
299 		return -EINVAL;
300 
301 	if (ac >= IEEE80211_NUM_ACS)
302 		return -EINVAL;
303 
304 	sta->airtime[ac].aql_limit_low = q_limit_l;
305 	sta->airtime[ac].aql_limit_high = q_limit_h;
306 
307 	return count;
308 }
309 STA_OPS_RW(aql);
310 
311 
312 static ssize_t sta_agg_status_read(struct file *file, char __user *userbuf,
313 					size_t count, loff_t *ppos)
314 {
315 	char buf[71 + IEEE80211_NUM_TIDS * 40], *p = buf;
316 	int i;
317 	struct sta_info *sta = file->private_data;
318 	struct tid_ampdu_rx *tid_rx;
319 	struct tid_ampdu_tx *tid_tx;
320 
321 	rcu_read_lock();
322 
323 	p += scnprintf(p, sizeof(buf) + buf - p, "next dialog_token: %#02x\n",
324 			sta->ampdu_mlme.dialog_token_allocator + 1);
325 	p += scnprintf(p, sizeof(buf) + buf - p,
326 		       "TID\t\tRX\tDTKN\tSSN\t\tTX\tDTKN\tpending\n");
327 
328 	for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
329 		bool tid_rx_valid;
330 
331 		tid_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[i]);
332 		tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[i]);
333 		tid_rx_valid = test_bit(i, sta->ampdu_mlme.agg_session_valid);
334 
335 		p += scnprintf(p, sizeof(buf) + buf - p, "%02d", i);
336 		p += scnprintf(p, sizeof(buf) + buf - p, "\t\t%x",
337 			       tid_rx_valid);
338 		p += scnprintf(p, sizeof(buf) + buf - p, "\t%#.2x",
339 			       tid_rx_valid ?
340 					sta->ampdu_mlme.tid_rx_token[i] : 0);
341 		p += scnprintf(p, sizeof(buf) + buf - p, "\t%#.3x",
342 				tid_rx ? tid_rx->ssn : 0);
343 
344 		p += scnprintf(p, sizeof(buf) + buf - p, "\t\t%x", !!tid_tx);
345 		p += scnprintf(p, sizeof(buf) + buf - p, "\t%#.2x",
346 				tid_tx ? tid_tx->dialog_token : 0);
347 		p += scnprintf(p, sizeof(buf) + buf - p, "\t%03d",
348 				tid_tx ? skb_queue_len(&tid_tx->pending) : 0);
349 		p += scnprintf(p, sizeof(buf) + buf - p, "\n");
350 	}
351 	rcu_read_unlock();
352 
353 	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
354 }
355 
356 static ssize_t sta_agg_status_write(struct file *file, const char __user *userbuf,
357 				    size_t count, loff_t *ppos)
358 {
359 	char _buf[25] = {}, *buf = _buf;
360 	struct sta_info *sta = file->private_data;
361 	bool start, tx;
362 	unsigned long tid;
363 	char *pos;
364 	int ret, timeout = 5000;
365 
366 	if (count > sizeof(_buf))
367 		return -EINVAL;
368 
369 	if (copy_from_user(buf, userbuf, count))
370 		return -EFAULT;
371 
372 	buf[sizeof(_buf) - 1] = '\0';
373 	pos = buf;
374 	buf = strsep(&pos, " ");
375 	if (!buf)
376 		return -EINVAL;
377 
378 	if (!strcmp(buf, "tx"))
379 		tx = true;
380 	else if (!strcmp(buf, "rx"))
381 		tx = false;
382 	else
383 		return -EINVAL;
384 
385 	buf = strsep(&pos, " ");
386 	if (!buf)
387 		return -EINVAL;
388 	if (!strcmp(buf, "start")) {
389 		start = true;
390 		if (!tx)
391 			return -EINVAL;
392 	} else if (!strcmp(buf, "stop")) {
393 		start = false;
394 	} else {
395 		return -EINVAL;
396 	}
397 
398 	buf = strsep(&pos, " ");
399 	if (!buf)
400 		return -EINVAL;
401 	if (sscanf(buf, "timeout=%d", &timeout) == 1) {
402 		buf = strsep(&pos, " ");
403 		if (!buf || !tx || !start)
404 			return -EINVAL;
405 	}
406 
407 	ret = kstrtoul(buf, 0, &tid);
408 	if (ret || tid >= IEEE80211_NUM_TIDS)
409 		return -EINVAL;
410 
411 	if (tx) {
412 		if (start)
413 			ret = ieee80211_start_tx_ba_session(&sta->sta, tid,
414 							    timeout);
415 		else
416 			ret = ieee80211_stop_tx_ba_session(&sta->sta, tid);
417 	} else {
418 		__ieee80211_stop_rx_ba_session(sta, tid, WLAN_BACK_RECIPIENT,
419 					       3, true);
420 		ret = 0;
421 	}
422 
423 	return ret ?: count;
424 }
425 STA_OPS_RW(agg_status);
426 
427 static ssize_t sta_ht_capa_read(struct file *file, char __user *userbuf,
428 				size_t count, loff_t *ppos)
429 {
430 #define PRINT_HT_CAP(_cond, _str) \
431 	do { \
432 	if (_cond) \
433 			p += scnprintf(p, sizeof(buf)+buf-p, "\t" _str "\n"); \
434 	} while (0)
435 	char buf[512], *p = buf;
436 	int i;
437 	struct sta_info *sta = file->private_data;
438 	struct ieee80211_sta_ht_cap *htc = &sta->sta.ht_cap;
439 
440 	p += scnprintf(p, sizeof(buf) + buf - p, "ht %ssupported\n",
441 			htc->ht_supported ? "" : "not ");
442 	if (htc->ht_supported) {
443 		p += scnprintf(p, sizeof(buf)+buf-p, "cap: %#.4x\n", htc->cap);
444 
445 		PRINT_HT_CAP((htc->cap & BIT(0)), "RX LDPC");
446 		PRINT_HT_CAP((htc->cap & BIT(1)), "HT20/HT40");
447 		PRINT_HT_CAP(!(htc->cap & BIT(1)), "HT20");
448 
449 		PRINT_HT_CAP(((htc->cap >> 2) & 0x3) == 0, "Static SM Power Save");
450 		PRINT_HT_CAP(((htc->cap >> 2) & 0x3) == 1, "Dynamic SM Power Save");
451 		PRINT_HT_CAP(((htc->cap >> 2) & 0x3) == 3, "SM Power Save disabled");
452 
453 		PRINT_HT_CAP((htc->cap & BIT(4)), "RX Greenfield");
454 		PRINT_HT_CAP((htc->cap & BIT(5)), "RX HT20 SGI");
455 		PRINT_HT_CAP((htc->cap & BIT(6)), "RX HT40 SGI");
456 		PRINT_HT_CAP((htc->cap & BIT(7)), "TX STBC");
457 
458 		PRINT_HT_CAP(((htc->cap >> 8) & 0x3) == 0, "No RX STBC");
459 		PRINT_HT_CAP(((htc->cap >> 8) & 0x3) == 1, "RX STBC 1-stream");
460 		PRINT_HT_CAP(((htc->cap >> 8) & 0x3) == 2, "RX STBC 2-streams");
461 		PRINT_HT_CAP(((htc->cap >> 8) & 0x3) == 3, "RX STBC 3-streams");
462 
463 		PRINT_HT_CAP((htc->cap & BIT(10)), "HT Delayed Block Ack");
464 
465 		PRINT_HT_CAP(!(htc->cap & BIT(11)), "Max AMSDU length: "
466 			     "3839 bytes");
467 		PRINT_HT_CAP((htc->cap & BIT(11)), "Max AMSDU length: "
468 			     "7935 bytes");
469 
470 		/*
471 		 * For beacons and probe response this would mean the BSS
472 		 * does or does not allow the usage of DSSS/CCK HT40.
473 		 * Otherwise it means the STA does or does not use
474 		 * DSSS/CCK HT40.
475 		 */
476 		PRINT_HT_CAP((htc->cap & BIT(12)), "DSSS/CCK HT40");
477 		PRINT_HT_CAP(!(htc->cap & BIT(12)), "No DSSS/CCK HT40");
478 
479 		/* BIT(13) is reserved */
480 
481 		PRINT_HT_CAP((htc->cap & BIT(14)), "40 MHz Intolerant");
482 
483 		PRINT_HT_CAP((htc->cap & BIT(15)), "L-SIG TXOP protection");
484 
485 		p += scnprintf(p, sizeof(buf)+buf-p, "ampdu factor/density: %d/%d\n",
486 				htc->ampdu_factor, htc->ampdu_density);
487 		p += scnprintf(p, sizeof(buf)+buf-p, "MCS mask:");
488 
489 		for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
490 			p += scnprintf(p, sizeof(buf)+buf-p, " %.2x",
491 					htc->mcs.rx_mask[i]);
492 		p += scnprintf(p, sizeof(buf)+buf-p, "\n");
493 
494 		/* If not set this is meaningless */
495 		if (le16_to_cpu(htc->mcs.rx_highest)) {
496 			p += scnprintf(p, sizeof(buf)+buf-p,
497 				       "MCS rx highest: %d Mbps\n",
498 				       le16_to_cpu(htc->mcs.rx_highest));
499 		}
500 
501 		p += scnprintf(p, sizeof(buf)+buf-p, "MCS tx params: %x\n",
502 				htc->mcs.tx_params);
503 	}
504 
505 	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
506 }
507 STA_OPS(ht_capa);
508 
509 static ssize_t sta_vht_capa_read(struct file *file, char __user *userbuf,
510 				 size_t count, loff_t *ppos)
511 {
512 	char buf[512], *p = buf;
513 	struct sta_info *sta = file->private_data;
514 	struct ieee80211_sta_vht_cap *vhtc = &sta->sta.vht_cap;
515 
516 	p += scnprintf(p, sizeof(buf) + buf - p, "VHT %ssupported\n",
517 			vhtc->vht_supported ? "" : "not ");
518 	if (vhtc->vht_supported) {
519 		p += scnprintf(p, sizeof(buf) + buf - p, "cap: %#.8x\n",
520 			       vhtc->cap);
521 #define PFLAG(a, b)							\
522 		do {							\
523 			if (vhtc->cap & IEEE80211_VHT_CAP_ ## a)	\
524 				p += scnprintf(p, sizeof(buf) + buf - p, \
525 					       "\t\t%s\n", b);		\
526 		} while (0)
527 
528 		switch (vhtc->cap & 0x3) {
529 		case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895:
530 			p += scnprintf(p, sizeof(buf) + buf - p,
531 				       "\t\tMAX-MPDU-3895\n");
532 			break;
533 		case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991:
534 			p += scnprintf(p, sizeof(buf) + buf - p,
535 				       "\t\tMAX-MPDU-7991\n");
536 			break;
537 		case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454:
538 			p += scnprintf(p, sizeof(buf) + buf - p,
539 				       "\t\tMAX-MPDU-11454\n");
540 			break;
541 		default:
542 			p += scnprintf(p, sizeof(buf) + buf - p,
543 				       "\t\tMAX-MPDU-UNKNOWN\n");
544 		}
545 		switch (vhtc->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
546 		case 0:
547 			p += scnprintf(p, sizeof(buf) + buf - p,
548 				       "\t\t80Mhz\n");
549 			break;
550 		case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
551 			p += scnprintf(p, sizeof(buf) + buf - p,
552 				       "\t\t160Mhz\n");
553 			break;
554 		case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
555 			p += scnprintf(p, sizeof(buf) + buf - p,
556 				       "\t\t80+80Mhz\n");
557 			break;
558 		default:
559 			p += scnprintf(p, sizeof(buf) + buf - p,
560 				       "\t\tUNKNOWN-MHZ: 0x%x\n",
561 				       (vhtc->cap >> 2) & 0x3);
562 		}
563 		PFLAG(RXLDPC, "RXLDPC");
564 		PFLAG(SHORT_GI_80, "SHORT-GI-80");
565 		PFLAG(SHORT_GI_160, "SHORT-GI-160");
566 		PFLAG(TXSTBC, "TXSTBC");
567 		p += scnprintf(p, sizeof(buf) + buf - p,
568 			       "\t\tRXSTBC_%d\n", (vhtc->cap >> 8) & 0x7);
569 		PFLAG(SU_BEAMFORMER_CAPABLE, "SU-BEAMFORMER-CAPABLE");
570 		PFLAG(SU_BEAMFORMEE_CAPABLE, "SU-BEAMFORMEE-CAPABLE");
571 		p += scnprintf(p, sizeof(buf) + buf - p,
572 			"\t\tBEAMFORMEE-STS: 0x%x\n",
573 			(vhtc->cap & IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK) >>
574 			IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT);
575 		p += scnprintf(p, sizeof(buf) + buf - p,
576 			"\t\tSOUNDING-DIMENSIONS: 0x%x\n",
577 			(vhtc->cap & IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK)
578 			>> IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT);
579 		PFLAG(MU_BEAMFORMER_CAPABLE, "MU-BEAMFORMER-CAPABLE");
580 		PFLAG(MU_BEAMFORMEE_CAPABLE, "MU-BEAMFORMEE-CAPABLE");
581 		PFLAG(VHT_TXOP_PS, "TXOP-PS");
582 		PFLAG(HTC_VHT, "HTC-VHT");
583 		p += scnprintf(p, sizeof(buf) + buf - p,
584 			"\t\tMPDU-LENGTH-EXPONENT: 0x%x\n",
585 			(vhtc->cap & IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
586 			IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT);
587 		PFLAG(VHT_LINK_ADAPTATION_VHT_UNSOL_MFB,
588 		      "LINK-ADAPTATION-VHT-UNSOL-MFB");
589 		p += scnprintf(p, sizeof(buf) + buf - p,
590 			"\t\tLINK-ADAPTATION-VHT-MRQ-MFB: 0x%x\n",
591 			(vhtc->cap & IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB) >> 26);
592 		PFLAG(RX_ANTENNA_PATTERN, "RX-ANTENNA-PATTERN");
593 		PFLAG(TX_ANTENNA_PATTERN, "TX-ANTENNA-PATTERN");
594 
595 		p += scnprintf(p, sizeof(buf)+buf-p, "RX MCS: %.4x\n",
596 			       le16_to_cpu(vhtc->vht_mcs.rx_mcs_map));
597 		if (vhtc->vht_mcs.rx_highest)
598 			p += scnprintf(p, sizeof(buf)+buf-p,
599 				       "MCS RX highest: %d Mbps\n",
600 				       le16_to_cpu(vhtc->vht_mcs.rx_highest));
601 		p += scnprintf(p, sizeof(buf)+buf-p, "TX MCS: %.4x\n",
602 			       le16_to_cpu(vhtc->vht_mcs.tx_mcs_map));
603 		if (vhtc->vht_mcs.tx_highest)
604 			p += scnprintf(p, sizeof(buf)+buf-p,
605 				       "MCS TX highest: %d Mbps\n",
606 				       le16_to_cpu(vhtc->vht_mcs.tx_highest));
607 #undef PFLAG
608 	}
609 
610 	return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
611 }
612 STA_OPS(vht_capa);
613 
614 static ssize_t sta_he_capa_read(struct file *file, char __user *userbuf,
615 				size_t count, loff_t *ppos)
616 {
617 	char *buf, *p;
618 	size_t buf_sz = PAGE_SIZE;
619 	struct sta_info *sta = file->private_data;
620 	struct ieee80211_sta_he_cap *hec = &sta->sta.he_cap;
621 	struct ieee80211_he_mcs_nss_supp *nss = &hec->he_mcs_nss_supp;
622 	u8 ppe_size;
623 	u8 *cap;
624 	int i;
625 	ssize_t ret;
626 
627 	buf = kmalloc(buf_sz, GFP_KERNEL);
628 	if (!buf)
629 		return -ENOMEM;
630 	p = buf;
631 
632 	p += scnprintf(p, buf_sz + buf - p, "HE %ssupported\n",
633 		       hec->has_he ? "" : "not ");
634 	if (!hec->has_he)
635 		goto out;
636 
637 	cap = hec->he_cap_elem.mac_cap_info;
638 	p += scnprintf(p, buf_sz + buf - p,
639 		       "MAC-CAP: %#.2x %#.2x %#.2x %#.2x %#.2x %#.2x\n",
640 		       cap[0], cap[1], cap[2], cap[3], cap[4], cap[5]);
641 
642 #define PRINT(fmt, ...)							\
643 	p += scnprintf(p, buf_sz + buf - p, "\t\t" fmt "\n",		\
644 		       ##__VA_ARGS__)
645 
646 #define PFLAG(t, n, a, b)						\
647 	do {								\
648 		if (cap[n] & IEEE80211_HE_##t##_CAP##n##_##a)		\
649 			PRINT("%s", b);					\
650 	} while (0)
651 
652 #define PFLAG_RANGE(t, i, n, s, m, off, fmt)				\
653 	do {								\
654 		u8 msk = IEEE80211_HE_##t##_CAP##i##_##n##_MASK;	\
655 		u8 idx = ((cap[i] & msk) >> (ffs(msk) - 1)) + off;	\
656 		PRINT(fmt, (s << idx) + (m * idx));			\
657 	} while (0)
658 
659 #define PFLAG_RANGE_DEFAULT(t, i, n, s, m, off, fmt, a, b)		\
660 	do {								\
661 		if (cap[i] == IEEE80211_HE_##t ##_CAP##i##_##n##_##a) {	\
662 			PRINT("%s", b);					\
663 			break;						\
664 		}							\
665 		PFLAG_RANGE(t, i, n, s, m, off, fmt);			\
666 	} while (0)
667 
668 	PFLAG(MAC, 0, HTC_HE, "HTC-HE");
669 	PFLAG(MAC, 0, TWT_REQ, "TWT-REQ");
670 	PFLAG(MAC, 0, TWT_RES, "TWT-RES");
671 	PFLAG_RANGE_DEFAULT(MAC, 0, DYNAMIC_FRAG, 0, 1, 0,
672 			    "DYNAMIC-FRAG-LEVEL-%d", NOT_SUPP, "NOT-SUPP");
673 	PFLAG_RANGE_DEFAULT(MAC, 0, MAX_NUM_FRAG_MSDU, 1, 0, 0,
674 			    "MAX-NUM-FRAG-MSDU-%d", UNLIMITED, "UNLIMITED");
675 
676 	PFLAG_RANGE_DEFAULT(MAC, 1, MIN_FRAG_SIZE, 128, 0, -1,
677 			    "MIN-FRAG-SIZE-%d", UNLIMITED, "UNLIMITED");
678 	PFLAG_RANGE_DEFAULT(MAC, 1, TF_MAC_PAD_DUR, 0, 8, 0,
679 			    "TF-MAC-PAD-DUR-%dUS", MASK, "UNKNOWN");
680 	PFLAG_RANGE(MAC, 1, MULTI_TID_AGG_RX_QOS, 0, 1, 1,
681 		    "MULTI-TID-AGG-RX-QOS-%d");
682 
683 	if (cap[0] & IEEE80211_HE_MAC_CAP0_HTC_HE) {
684 		switch (((cap[2] << 1) | (cap[1] >> 7)) & 0x3) {
685 		case 0:
686 			PRINT("LINK-ADAPTATION-NO-FEEDBACK");
687 			break;
688 		case 1:
689 			PRINT("LINK-ADAPTATION-RESERVED");
690 			break;
691 		case 2:
692 			PRINT("LINK-ADAPTATION-UNSOLICITED-FEEDBACK");
693 			break;
694 		case 3:
695 			PRINT("LINK-ADAPTATION-BOTH");
696 			break;
697 		}
698 	}
699 
700 	PFLAG(MAC, 2, ALL_ACK, "ALL-ACK");
701 	PFLAG(MAC, 2, TRS, "TRS");
702 	PFLAG(MAC, 2, BSR, "BSR");
703 	PFLAG(MAC, 2, BCAST_TWT, "BCAST-TWT");
704 	PFLAG(MAC, 2, 32BIT_BA_BITMAP, "32BIT-BA-BITMAP");
705 	PFLAG(MAC, 2, MU_CASCADING, "MU-CASCADING");
706 	PFLAG(MAC, 2, ACK_EN, "ACK-EN");
707 
708 	PFLAG(MAC, 3, OMI_CONTROL, "OMI-CONTROL");
709 	PFLAG(MAC, 3, OFDMA_RA, "OFDMA-RA");
710 
711 	switch (cap[3] & IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK) {
712 	case IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_USE_VHT:
713 		PRINT("MAX-AMPDU-LEN-EXP-USE-VHT");
714 		break;
715 	case IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_1:
716 		PRINT("MAX-AMPDU-LEN-EXP-VHT-1");
717 		break;
718 	case IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_2:
719 		PRINT("MAX-AMPDU-LEN-EXP-VHT-2");
720 		break;
721 	case IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_RESERVED:
722 		PRINT("MAX-AMPDU-LEN-EXP-RESERVED");
723 		break;
724 	}
725 
726 	PFLAG(MAC, 3, AMSDU_FRAG, "AMSDU-FRAG");
727 	PFLAG(MAC, 3, FLEX_TWT_SCHED, "FLEX-TWT-SCHED");
728 	PFLAG(MAC, 3, RX_CTRL_FRAME_TO_MULTIBSS, "RX-CTRL-FRAME-TO-MULTIBSS");
729 
730 	PFLAG(MAC, 4, BSRP_BQRP_A_MPDU_AGG, "BSRP-BQRP-A-MPDU-AGG");
731 	PFLAG(MAC, 4, QTP, "QTP");
732 	PFLAG(MAC, 4, BQR, "BQR");
733 	PFLAG(MAC, 4, SRP_RESP, "SRP-RESP");
734 	PFLAG(MAC, 4, NDP_FB_REP, "NDP-FB-REP");
735 	PFLAG(MAC, 4, OPS, "OPS");
736 	PFLAG(MAC, 4, AMDSU_IN_AMPDU, "AMSDU-IN-AMPDU");
737 
738 	PRINT("MULTI-TID-AGG-TX-QOS-%d", ((cap[5] << 1) | (cap[4] >> 7)) & 0x7);
739 
740 	PFLAG(MAC, 5, SUBCHAN_SELECVITE_TRANSMISSION,
741 	      "SUBCHAN-SELECVITE-TRANSMISSION");
742 	PFLAG(MAC, 5, UL_2x996_TONE_RU, "UL-2x996-TONE-RU");
743 	PFLAG(MAC, 5, OM_CTRL_UL_MU_DATA_DIS_RX, "OM-CTRL-UL-MU-DATA-DIS-RX");
744 	PFLAG(MAC, 5, HE_DYNAMIC_SM_PS, "HE-DYNAMIC-SM-PS");
745 	PFLAG(MAC, 5, PUNCTURED_SOUNDING, "PUNCTURED-SOUNDING");
746 	PFLAG(MAC, 5, HT_VHT_TRIG_FRAME_RX, "HT-VHT-TRIG-FRAME-RX");
747 
748 	cap = hec->he_cap_elem.phy_cap_info;
749 	p += scnprintf(p, buf_sz + buf - p,
750 		       "PHY CAP: %#.2x %#.2x %#.2x %#.2x %#.2x %#.2x %#.2x %#.2x %#.2x %#.2x %#.2x\n",
751 		       cap[0], cap[1], cap[2], cap[3], cap[4], cap[5], cap[6],
752 		       cap[7], cap[8], cap[9], cap[10]);
753 
754 	PFLAG(PHY, 0, CHANNEL_WIDTH_SET_40MHZ_IN_2G,
755 	      "CHANNEL-WIDTH-SET-40MHZ-IN-2G");
756 	PFLAG(PHY, 0, CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G,
757 	      "CHANNEL-WIDTH-SET-40MHZ-80MHZ-IN-5G");
758 	PFLAG(PHY, 0, CHANNEL_WIDTH_SET_160MHZ_IN_5G,
759 	      "CHANNEL-WIDTH-SET-160MHZ-IN-5G");
760 	PFLAG(PHY, 0, CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G,
761 	      "CHANNEL-WIDTH-SET-80PLUS80-MHZ-IN-5G");
762 	PFLAG(PHY, 0, CHANNEL_WIDTH_SET_RU_MAPPING_IN_2G,
763 	      "CHANNEL-WIDTH-SET-RU-MAPPING-IN-2G");
764 	PFLAG(PHY, 0, CHANNEL_WIDTH_SET_RU_MAPPING_IN_5G,
765 	      "CHANNEL-WIDTH-SET-RU-MAPPING-IN-5G");
766 
767 	switch (cap[1] & IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK) {
768 	case IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_80MHZ_ONLY_SECOND_20MHZ:
769 		PRINT("PREAMBLE-PUNC-RX-80MHZ-ONLY-SECOND-20MHZ");
770 		break;
771 	case IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_80MHZ_ONLY_SECOND_40MHZ:
772 		PRINT("PREAMBLE-PUNC-RX-80MHZ-ONLY-SECOND-40MHZ");
773 		break;
774 	case IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_160MHZ_ONLY_SECOND_20MHZ:
775 		PRINT("PREAMBLE-PUNC-RX-160MHZ-ONLY-SECOND-20MHZ");
776 		break;
777 	case IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_160MHZ_ONLY_SECOND_40MHZ:
778 		PRINT("PREAMBLE-PUNC-RX-160MHZ-ONLY-SECOND-40MHZ");
779 		break;
780 	}
781 
782 	PFLAG(PHY, 1, DEVICE_CLASS_A,
783 	      "IEEE80211-HE-PHY-CAP1-DEVICE-CLASS-A");
784 	PFLAG(PHY, 1, LDPC_CODING_IN_PAYLOAD,
785 	      "LDPC-CODING-IN-PAYLOAD");
786 	PFLAG(PHY, 1, HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US,
787 	      "HY-CAP1-HE-LTF-AND-GI-FOR-HE-PPDUS-0-8US");
788 	PRINT("MIDAMBLE-RX-MAX-NSTS-%d", ((cap[2] << 1) | (cap[1] >> 7)) & 0x3);
789 
790 	PFLAG(PHY, 2, NDP_4x_LTF_AND_3_2US, "NDP-4X-LTF-AND-3-2US");
791 	PFLAG(PHY, 2, STBC_TX_UNDER_80MHZ, "STBC-TX-UNDER-80MHZ");
792 	PFLAG(PHY, 2, STBC_RX_UNDER_80MHZ, "STBC-RX-UNDER-80MHZ");
793 	PFLAG(PHY, 2, DOPPLER_TX, "DOPPLER-TX");
794 	PFLAG(PHY, 2, DOPPLER_RX, "DOPPLER-RX");
795 	PFLAG(PHY, 2, UL_MU_FULL_MU_MIMO, "UL-MU-FULL-MU-MIMO");
796 	PFLAG(PHY, 2, UL_MU_PARTIAL_MU_MIMO, "UL-MU-PARTIAL-MU-MIMO");
797 
798 	switch (cap[3] & IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK) {
799 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_NO_DCM:
800 		PRINT("DCM-MAX-CONST-TX-NO-DCM");
801 		break;
802 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_BPSK:
803 		PRINT("DCM-MAX-CONST-TX-BPSK");
804 		break;
805 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_QPSK:
806 		PRINT("DCM-MAX-CONST-TX-QPSK");
807 		break;
808 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_16_QAM:
809 		PRINT("DCM-MAX-CONST-TX-16-QAM");
810 		break;
811 	}
812 
813 	PFLAG(PHY, 3, DCM_MAX_TX_NSS_1, "DCM-MAX-TX-NSS-1");
814 	PFLAG(PHY, 3, DCM_MAX_TX_NSS_2, "DCM-MAX-TX-NSS-2");
815 
816 	switch (cap[3] & IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK) {
817 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_NO_DCM:
818 		PRINT("DCM-MAX-CONST-RX-NO-DCM");
819 		break;
820 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_BPSK:
821 		PRINT("DCM-MAX-CONST-RX-BPSK");
822 		break;
823 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_QPSK:
824 		PRINT("DCM-MAX-CONST-RX-QPSK");
825 		break;
826 	case IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_16_QAM:
827 		PRINT("DCM-MAX-CONST-RX-16-QAM");
828 		break;
829 	}
830 
831 	PFLAG(PHY, 3, DCM_MAX_RX_NSS_1, "DCM-MAX-RX-NSS-1");
832 	PFLAG(PHY, 3, DCM_MAX_RX_NSS_2, "DCM-MAX-RX-NSS-2");
833 	PFLAG(PHY, 3, RX_HE_MU_PPDU_FROM_NON_AP_STA,
834 	      "RX-HE-MU-PPDU-FROM-NON-AP-STA");
835 	PFLAG(PHY, 3, SU_BEAMFORMER, "SU-BEAMFORMER");
836 
837 	PFLAG(PHY, 4, SU_BEAMFORMEE, "SU-BEAMFORMEE");
838 	PFLAG(PHY, 4, MU_BEAMFORMER, "MU-BEAMFORMER");
839 
840 	PFLAG_RANGE(PHY, 4, BEAMFORMEE_MAX_STS_UNDER_80MHZ, 0, 1, 4,
841 		    "BEAMFORMEE-MAX-STS-UNDER-%d");
842 	PFLAG_RANGE(PHY, 4, BEAMFORMEE_MAX_STS_ABOVE_80MHZ, 0, 1, 4,
843 		    "BEAMFORMEE-MAX-STS-ABOVE-%d");
844 
845 	PFLAG_RANGE(PHY, 5, BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ, 0, 1, 1,
846 		    "NUM-SND-DIM-UNDER-80MHZ-%d");
847 	PFLAG_RANGE(PHY, 5, BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ, 0, 1, 1,
848 		    "NUM-SND-DIM-ABOVE-80MHZ-%d");
849 	PFLAG(PHY, 5, NG16_SU_FEEDBACK, "NG16-SU-FEEDBACK");
850 	PFLAG(PHY, 5, NG16_MU_FEEDBACK, "NG16-MU-FEEDBACK");
851 
852 	PFLAG(PHY, 6, CODEBOOK_SIZE_42_SU, "CODEBOOK-SIZE-42-SU");
853 	PFLAG(PHY, 6, CODEBOOK_SIZE_75_MU, "CODEBOOK-SIZE-75-MU");
854 	PFLAG(PHY, 6, TRIG_SU_BEAMFORMER_FB, "TRIG-SU-BEAMFORMER-FB");
855 	PFLAG(PHY, 6, TRIG_MU_BEAMFORMER_FB, "TRIG-MU-BEAMFORMER-FB");
856 	PFLAG(PHY, 6, TRIG_CQI_FB, "TRIG-CQI-FB");
857 	PFLAG(PHY, 6, PARTIAL_BW_EXT_RANGE, "PARTIAL-BW-EXT-RANGE");
858 	PFLAG(PHY, 6, PARTIAL_BANDWIDTH_DL_MUMIMO,
859 	      "PARTIAL-BANDWIDTH-DL-MUMIMO");
860 	PFLAG(PHY, 6, PPE_THRESHOLD_PRESENT, "PPE-THRESHOLD-PRESENT");
861 
862 	PFLAG(PHY, 7, SRP_BASED_SR, "SRP-BASED-SR");
863 	PFLAG(PHY, 7, POWER_BOOST_FACTOR_AR, "POWER-BOOST-FACTOR-AR");
864 	PFLAG(PHY, 7, HE_SU_MU_PPDU_4XLTF_AND_08_US_GI,
865 	      "HE-SU-MU-PPDU-4XLTF-AND-08-US-GI");
866 	PFLAG_RANGE(PHY, 7, MAX_NC, 0, 1, 1, "MAX-NC-%d");
867 	PFLAG(PHY, 7, STBC_TX_ABOVE_80MHZ, "STBC-TX-ABOVE-80MHZ");
868 	PFLAG(PHY, 7, STBC_RX_ABOVE_80MHZ, "STBC-RX-ABOVE-80MHZ");
869 
870 	PFLAG(PHY, 8, HE_ER_SU_PPDU_4XLTF_AND_08_US_GI,
871 	      "HE-ER-SU-PPDU-4XLTF-AND-08-US-GI");
872 	PFLAG(PHY, 8, 20MHZ_IN_40MHZ_HE_PPDU_IN_2G,
873 	      "20MHZ-IN-40MHZ-HE-PPDU-IN-2G");
874 	PFLAG(PHY, 8, 20MHZ_IN_160MHZ_HE_PPDU, "20MHZ-IN-160MHZ-HE-PPDU");
875 	PFLAG(PHY, 8, 80MHZ_IN_160MHZ_HE_PPDU, "80MHZ-IN-160MHZ-HE-PPDU");
876 	PFLAG(PHY, 8, HE_ER_SU_1XLTF_AND_08_US_GI,
877 	      "HE-ER-SU-1XLTF-AND-08-US-GI");
878 	PFLAG(PHY, 8, MIDAMBLE_RX_TX_2X_AND_1XLTF,
879 	      "MIDAMBLE-RX-TX-2X-AND-1XLTF");
880 
881 	switch (cap[8] & IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_MASK) {
882 	case IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_242:
883 		PRINT("DCM-MAX-RU-242");
884 		break;
885 	case IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_484:
886 		PRINT("DCM-MAX-RU-484");
887 		break;
888 	case IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_996:
889 		PRINT("DCM-MAX-RU-996");
890 		break;
891 	case IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_2x996:
892 		PRINT("DCM-MAX-RU-2x996");
893 		break;
894 	}
895 
896 	PFLAG(PHY, 9, LONGER_THAN_16_SIGB_OFDM_SYM,
897 	      "LONGER-THAN-16-SIGB-OFDM-SYM");
898 	PFLAG(PHY, 9, NON_TRIGGERED_CQI_FEEDBACK,
899 	      "NON-TRIGGERED-CQI-FEEDBACK");
900 	PFLAG(PHY, 9, TX_1024_QAM_LESS_THAN_242_TONE_RU,
901 	      "TX-1024-QAM-LESS-THAN-242-TONE-RU");
902 	PFLAG(PHY, 9, RX_1024_QAM_LESS_THAN_242_TONE_RU,
903 	      "RX-1024-QAM-LESS-THAN-242-TONE-RU");
904 	PFLAG(PHY, 9, RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB,
905 	      "RX-FULL-BW-SU-USING-MU-WITH-COMP-SIGB");
906 	PFLAG(PHY, 9, RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB,
907 	      "RX-FULL-BW-SU-USING-MU-WITH-NON-COMP-SIGB");
908 
909 	switch (cap[9] & IEEE80211_HE_PHY_CAP9_NOMIMAL_PKT_PADDING_MASK) {
910 	case IEEE80211_HE_PHY_CAP9_NOMIMAL_PKT_PADDING_0US:
911 		PRINT("NOMINAL-PACKET-PADDING-0US");
912 		break;
913 	case IEEE80211_HE_PHY_CAP9_NOMIMAL_PKT_PADDING_8US:
914 		PRINT("NOMINAL-PACKET-PADDING-8US");
915 		break;
916 	case IEEE80211_HE_PHY_CAP9_NOMIMAL_PKT_PADDING_16US:
917 		PRINT("NOMINAL-PACKET-PADDING-16US");
918 		break;
919 	}
920 
921 #undef PFLAG_RANGE_DEFAULT
922 #undef PFLAG_RANGE
923 #undef PFLAG
924 
925 #define PRINT_NSS_SUPP(f, n)						\
926 	do {								\
927 		int _i;							\
928 		u16 v = le16_to_cpu(nss->f);				\
929 		p += scnprintf(p, buf_sz + buf - p, n ": %#.4x\n", v);	\
930 		for (_i = 0; _i < 8; _i += 2) {				\
931 			switch ((v >> _i) & 0x3) {			\
932 			case 0:						\
933 				PRINT(n "-%d-SUPPORT-0-7", _i / 2);	\
934 				break;					\
935 			case 1:						\
936 				PRINT(n "-%d-SUPPORT-0-9", _i / 2);	\
937 				break;					\
938 			case 2:						\
939 				PRINT(n "-%d-SUPPORT-0-11", _i / 2);	\
940 				break;					\
941 			case 3:						\
942 				PRINT(n "-%d-NOT-SUPPORTED", _i / 2);	\
943 				break;					\
944 			}						\
945 		}							\
946 	} while (0)
947 
948 	PRINT_NSS_SUPP(rx_mcs_80, "RX-MCS-80");
949 	PRINT_NSS_SUPP(tx_mcs_80, "TX-MCS-80");
950 
951 	if (cap[0] & IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) {
952 		PRINT_NSS_SUPP(rx_mcs_160, "RX-MCS-160");
953 		PRINT_NSS_SUPP(tx_mcs_160, "TX-MCS-160");
954 	}
955 
956 	if (cap[0] &
957 	    IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
958 		PRINT_NSS_SUPP(rx_mcs_80p80, "RX-MCS-80P80");
959 		PRINT_NSS_SUPP(tx_mcs_80p80, "TX-MCS-80P80");
960 	}
961 
962 #undef PRINT_NSS_SUPP
963 #undef PRINT
964 
965 	if (!(cap[6] & IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT))
966 		goto out;
967 
968 	p += scnprintf(p, buf_sz + buf - p, "PPE-THRESHOLDS: %#.2x",
969 		       hec->ppe_thres[0]);
970 
971 	ppe_size = ieee80211_he_ppe_size(hec->ppe_thres[0], cap);
972 	for (i = 1; i < ppe_size; i++) {
973 		p += scnprintf(p, buf_sz + buf - p, " %#.2x",
974 			       hec->ppe_thres[i]);
975 	}
976 	p += scnprintf(p, buf_sz + buf - p, "\n");
977 
978 out:
979 	ret = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
980 	kfree(buf);
981 	return ret;
982 }
983 STA_OPS(he_capa);
984 
985 #define DEBUGFS_ADD(name) \
986 	debugfs_create_file(#name, 0400, \
987 		sta->debugfs_dir, sta, &sta_ ##name## _ops);
988 
989 #define DEBUGFS_ADD_COUNTER(name, field)				\
990 	debugfs_create_ulong(#name, 0400, sta->debugfs_dir, &sta->field);
991 
992 void ieee80211_sta_debugfs_add(struct sta_info *sta)
993 {
994 	struct ieee80211_local *local = sta->local;
995 	struct ieee80211_sub_if_data *sdata = sta->sdata;
996 	struct dentry *stations_dir = sta->sdata->debugfs.subdir_stations;
997 	u8 mac[3*ETH_ALEN];
998 
999 	if (!stations_dir)
1000 		return;
1001 
1002 	snprintf(mac, sizeof(mac), "%pM", sta->sta.addr);
1003 
1004 	/*
1005 	 * This might fail due to a race condition:
1006 	 * When mac80211 unlinks a station, the debugfs entries
1007 	 * remain, but it is already possible to link a new
1008 	 * station with the same address which triggers adding
1009 	 * it to debugfs; therefore, if the old station isn't
1010 	 * destroyed quickly enough the old station's debugfs
1011 	 * dir might still be around.
1012 	 */
1013 	sta->debugfs_dir = debugfs_create_dir(mac, stations_dir);
1014 
1015 	DEBUGFS_ADD(flags);
1016 	DEBUGFS_ADD(aid);
1017 	DEBUGFS_ADD(num_ps_buf_frames);
1018 	DEBUGFS_ADD(last_seq_ctrl);
1019 	DEBUGFS_ADD(agg_status);
1020 	DEBUGFS_ADD(ht_capa);
1021 	DEBUGFS_ADD(vht_capa);
1022 	DEBUGFS_ADD(he_capa);
1023 
1024 	DEBUGFS_ADD_COUNTER(rx_duplicates, rx_stats.num_duplicates);
1025 	DEBUGFS_ADD_COUNTER(rx_fragments, rx_stats.fragments);
1026 	DEBUGFS_ADD_COUNTER(tx_filtered, status_stats.filtered);
1027 
1028 	if (local->ops->wake_tx_queue)
1029 		DEBUGFS_ADD(aqm);
1030 
1031 	if (wiphy_ext_feature_isset(local->hw.wiphy,
1032 				    NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
1033 		DEBUGFS_ADD(airtime);
1034 
1035 	if (wiphy_ext_feature_isset(local->hw.wiphy,
1036 				    NL80211_EXT_FEATURE_AQL))
1037 		DEBUGFS_ADD(aql);
1038 
1039 	debugfs_create_xul("driver_buffered_tids", 0400, sta->debugfs_dir,
1040 			   &sta->driver_buffered_tids);
1041 
1042 	drv_sta_add_debugfs(local, sdata, &sta->sta, sta->debugfs_dir);
1043 }
1044 
1045 void ieee80211_sta_debugfs_remove(struct sta_info *sta)
1046 {
1047 	debugfs_remove_recursive(sta->debugfs_dir);
1048 	sta->debugfs_dir = NULL;
1049 }
1050