xref: /linux/net/mac80211/ieee80211_i.h (revision ee1a5e92dba0a98cabe476c780e3af4f0ab88b27)
1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  * Copyright 2002-2005, Instant802 Networks, Inc.
4  * Copyright 2005, Devicescape Software, Inc.
5  * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
6  * Copyright 2007-2010	Johannes Berg <johannes@sipsolutions.net>
7  * Copyright 2013-2015  Intel Mobile Communications GmbH
8  * Copyright (C) 2018-2026 Intel Corporation
9  */
10 
11 #ifndef IEEE80211_I_H
12 #define IEEE80211_I_H
13 
14 #include <linux/kernel.h>
15 #include <linux/device.h>
16 #include <linux/if_ether.h>
17 #include <linux/interrupt.h>
18 #include <linux/list.h>
19 #include <linux/netdevice.h>
20 #include <linux/skbuff.h>
21 #include <linux/workqueue.h>
22 #include <linux/types.h>
23 #include <linux/spinlock.h>
24 #include <linux/etherdevice.h>
25 #include <linux/leds.h>
26 #include <linux/idr.h>
27 #include <linux/rhashtable.h>
28 #include <linux/rbtree.h>
29 #include <kunit/visibility.h>
30 #include <net/ieee80211_radiotap.h>
31 #include <net/cfg80211.h>
32 #include <net/mac80211.h>
33 #include <net/fq.h>
34 #include "key.h"
35 #include "sta_info.h"
36 #include "debug.h"
37 #include "drop.h"
38 
39 extern const struct cfg80211_ops mac80211_config_ops;
40 
41 struct ieee80211_local;
42 struct ieee80211_mesh_fast_tx;
43 
44 /* Maximum number of broadcast/multicast frames to buffer when some of the
45  * associated stations are using power saving. */
46 #define AP_MAX_BC_BUFFER 128
47 
48 /* Maximum number of frames buffered to all STAs, including multicast frames.
49  * Note: increasing this limit increases the potential memory requirement. Each
50  * frame can be up to about 2 kB long. */
51 #define TOTAL_MAX_TX_BUFFER 512
52 
53 /* Required encryption head and tailroom */
54 #define IEEE80211_ENCRYPT_HEADROOM 8
55 #define IEEE80211_ENCRYPT_TAILROOM 26 /* current max: GMAC/CMAC-256 MME */
56 
57 /* power level hasn't been configured (or set to automatic) */
58 #define IEEE80211_UNSET_POWER_LEVEL	INT_MIN
59 
60 /*
61  * Some APs experience problems when working with U-APSD. Decreasing the
62  * probability of that happening by using legacy mode for all ACs but VO isn't
63  * enough.
64  *
65  * Cisco 4410N originally forced us to enable VO by default only because it
66  * treated non-VO ACs as legacy.
67  *
68  * However some APs (notably Netgear R7000) silently reclassify packets to
69  * different ACs. Since u-APSD ACs require trigger frames for frame retrieval
70  * clients would never see some frames (e.g. ARP responses) or would fetch them
71  * accidentally after a long time.
72  *
73  * It makes little sense to enable u-APSD queues by default because it needs
74  * userspace applications to be aware of it to actually take advantage of the
75  * possible additional powersavings. Implicitly depending on driver autotrigger
76  * frame support doesn't make much sense.
77  */
78 #define IEEE80211_DEFAULT_UAPSD_QUEUES 0
79 
80 #define IEEE80211_DEFAULT_MAX_SP_LEN		\
81 	IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL
82 
83 extern const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS];
84 
85 #define IEEE80211_DEAUTH_FRAME_LEN	(24 /* hdr */ + 2 /* reason */)
86 
87 #define IEEE80211_MAX_NAN_INSTANCE_ID 255
88 
89 /*
90  * Current mac80211 implementation supports a maximum of 1600 AIDS
91  * for S1G interfaces. With regards to an S1G TIM, this covers 25 blocks
92  * as each block is 64 AIDs.
93  */
94 #define IEEE80211_MAX_SUPPORTED_S1G_AID	1600
95 #define IEEE80211_MAX_SUPPORTED_S1G_TIM_BLOCKS 25
96 
97 enum ieee80211_status_data {
98 	IEEE80211_STATUS_TYPE_MASK	= 0x00f,
99 	IEEE80211_STATUS_TYPE_INVALID	= 0,
100 	IEEE80211_STATUS_TYPE_SMPS	= 1,
101 	IEEE80211_STATUS_TYPE_NEG_TTLM	= 2,
102 	IEEE80211_STATUS_TYPE_UHR_OMP	= 3,
103 	IEEE80211_STATUS_SUBDATA_MASK	= 0x1ff0,
104 };
105 
106 static inline bool
107 ieee80211_sta_keep_active(struct sta_info *sta, u8 ac)
108 {
109 	/* Keep a station's queues on the active list for deficit accounting
110 	 * purposes if it was active or queued during the last 100ms.
111 	 */
112 	return time_before_eq(jiffies, sta->airtime[ac].last_active + HZ / 10);
113 }
114 
115 struct ieee80211_bss {
116 	u32 device_ts_beacon, device_ts_presp;
117 
118 	bool wmm_used;
119 	bool uapsd_supported;
120 
121 #define IEEE80211_MAX_SUPP_RATES 32
122 	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
123 	size_t supp_rates_len;
124 	struct ieee80211_rate *beacon_rate;
125 
126 	u32 vht_cap_info;
127 
128 	/*
129 	 * During association, we save an ERP value from a probe response so
130 	 * that we can feed ERP info to the driver when handling the
131 	 * association completes. these fields probably won't be up-to-date
132 	 * otherwise, you probably don't want to use them.
133 	 */
134 	bool has_erp_value;
135 	u8 erp_value;
136 
137 	/* Keep track of the corruption of the last beacon/probe response. */
138 	u8 corrupt_data;
139 
140 	/* Keep track of what bits of information we have valid info for. */
141 	u8 valid_data;
142 };
143 
144 /**
145  * enum ieee80211_bss_corrupt_data_flags - BSS data corruption flags
146  * @IEEE80211_BSS_CORRUPT_BEACON: last beacon frame received was corrupted
147  * @IEEE80211_BSS_CORRUPT_PROBE_RESP: last probe response received was corrupted
148  *
149  * These are bss flags that are attached to a bss in the
150  * @corrupt_data field of &struct ieee80211_bss.
151  */
152 enum ieee80211_bss_corrupt_data_flags {
153 	IEEE80211_BSS_CORRUPT_BEACON		= BIT(0),
154 	IEEE80211_BSS_CORRUPT_PROBE_RESP	= BIT(1)
155 };
156 
157 /**
158  * enum ieee80211_bss_valid_data_flags - BSS valid data flags
159  * @IEEE80211_BSS_VALID_WMM: WMM/UAPSD data was gathered from non-corrupt IE
160  * @IEEE80211_BSS_VALID_RATES: Supported rates were gathered from non-corrupt IE
161  * @IEEE80211_BSS_VALID_ERP: ERP flag was gathered from non-corrupt IE
162  *
163  * These are bss flags that are attached to a bss in the
164  * @valid_data field of &struct ieee80211_bss.  They show which parts
165  * of the data structure were received as a result of an un-corrupted
166  * beacon/probe response.
167  */
168 enum ieee80211_bss_valid_data_flags {
169 	IEEE80211_BSS_VALID_WMM			= BIT(1),
170 	IEEE80211_BSS_VALID_RATES		= BIT(2),
171 	IEEE80211_BSS_VALID_ERP			= BIT(3)
172 };
173 
174 typedef unsigned __bitwise ieee80211_tx_result;
175 #define TX_CONTINUE	((__force ieee80211_tx_result) 0u)
176 #define TX_DROP		((__force ieee80211_tx_result) 1u)
177 #define TX_QUEUED	((__force ieee80211_tx_result) 2u)
178 
179 #define IEEE80211_TX_UNICAST		BIT(1)
180 #define IEEE80211_TX_PS_BUFFERED	BIT(2)
181 
182 struct ieee80211_tx_data {
183 	struct sk_buff *skb;
184 	struct sk_buff_head skbs;
185 	struct ieee80211_local *local;
186 	struct ieee80211_sub_if_data *sdata;
187 	struct sta_info *sta;
188 	struct ieee80211_key *key;
189 	struct ieee80211_tx_rate rate;
190 
191 	unsigned int flags;
192 };
193 
194 static inline bool ieee80211_is_tx_data(struct sk_buff *skb)
195 {
196 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
197 	struct ieee80211_hdr *hdr = (void *)skb->data;
198 
199 	return info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP ||
200 	       ieee80211_is_data(hdr->frame_control);
201 }
202 
203 /**
204  * enum ieee80211_packet_rx_flags - packet RX flags
205  * @IEEE80211_RX_AMSDU: a-MSDU packet
206  * @IEEE80211_RX_MALFORMED_ACTION_FRM: action frame is malformed
207  * @IEEE80211_RX_DEFERRED_RELEASE: frame was subjected to receive reordering
208  *
209  * These are per-frame flags that are attached to a frame in the
210  * @rx_flags field of &struct ieee80211_rx_status.
211  */
212 enum ieee80211_packet_rx_flags {
213 	IEEE80211_RX_AMSDU			= BIT(3),
214 	IEEE80211_RX_MALFORMED_ACTION_FRM	= BIT(4),
215 	IEEE80211_RX_DEFERRED_RELEASE		= BIT(5),
216 };
217 
218 /**
219  * enum ieee80211_rx_flags - RX data flags
220  *
221  * @IEEE80211_RX_BEACON_REPORTED: This frame was already reported
222  *	to cfg80211_report_obss_beacon().
223  *
224  * These flags are used across handling multiple interfaces
225  * for a single frame.
226  */
227 enum ieee80211_rx_flags {
228 	IEEE80211_RX_BEACON_REPORTED	= BIT(0),
229 };
230 
231 struct ieee80211_rx_data {
232 	struct list_head *list;
233 	struct sk_buff *skb;
234 	struct ieee80211_local *local;
235 	struct ieee80211_sub_if_data *sdata;
236 	struct ieee80211_link_data *link;
237 	struct sta_info *sta;
238 	struct link_sta_info *link_sta;
239 	struct ieee80211_key *key;
240 
241 	unsigned int flags;
242 
243 	/*
244 	 * Index into sequence numbers array, 0..16
245 	 * since the last (16) is used for non-QoS,
246 	 * will be 16 on non-QoS frames.
247 	 */
248 	int seqno_idx;
249 
250 	/*
251 	 * Index into the security IV/PN arrays, 0..16
252 	 * since the last (16) is used for CCMP-encrypted
253 	 * management frames, will be set to 16 on mgmt
254 	 * frames and 0 on non-QoS frames.
255 	 */
256 	int security_idx;
257 
258 	int link_id;
259 
260 	union {
261 		struct {
262 			u32 iv32;
263 			u16 iv16;
264 		} tkip;
265 		struct {
266 			u8 pn[IEEE80211_CCMP_PN_LEN];
267 		} ccm_gcm;
268 	};
269 
270 	u8 link_addrs[3 * ETH_ALEN];
271 };
272 
273 struct ieee80211_csa_settings {
274 	const u16 *counter_offsets_beacon;
275 	const u16 *counter_offsets_presp;
276 
277 	int n_counter_offsets_beacon;
278 	int n_counter_offsets_presp;
279 
280 	u8 count;
281 };
282 
283 struct ieee80211_color_change_settings {
284 	u16 counter_offset_beacon;
285 	u16 counter_offset_presp;
286 	u8 count;
287 };
288 
289 struct beacon_data {
290 	u8 *head, *tail;
291 	int head_len, tail_len;
292 	struct ieee80211_meshconf_ie *meshconf;
293 	u16 cntdwn_counter_offsets[IEEE80211_MAX_CNTDWN_COUNTERS_NUM];
294 	u8 cntdwn_current_counter;
295 	struct cfg80211_mbssid_elems *mbssid_ies;
296 	struct cfg80211_rnr_elems *rnr_ies;
297 	struct rcu_head rcu_head;
298 };
299 
300 struct probe_resp {
301 	struct rcu_head rcu_head;
302 	int len;
303 	u16 cntdwn_counter_offsets[IEEE80211_MAX_CNTDWN_COUNTERS_NUM];
304 	u8 data[];
305 };
306 
307 struct fils_discovery_data {
308 	struct rcu_head rcu_head;
309 	int len;
310 	u8 data[];
311 };
312 
313 struct unsol_bcast_probe_resp_data {
314 	struct rcu_head rcu_head;
315 	int len;
316 	u8 data[];
317 };
318 
319 struct s1g_short_beacon_data {
320 	struct rcu_head rcu_head;
321 	u8 *short_head;
322 	u8 *short_tail;
323 	int short_head_len;
324 	int short_tail_len;
325 };
326 
327 struct ps_data {
328 	/* yes, this looks ugly, but guarantees that we can later use
329 	 * bitmap_empty :)
330 	 * NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
331 	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)]
332 			__aligned(__alignof__(unsigned long));
333 	struct sk_buff_head bc_buf;
334 	atomic_t num_sta_ps; /* number of stations in PS mode */
335 	int dtim_count;
336 	bool dtim_bc_mc;
337 	int sb_count; /* num short beacons til next long beacon */
338 };
339 
340 struct ieee80211_if_ap {
341 	struct list_head vlans; /* write-protected with RTNL and local->mtx */
342 
343 	struct ps_data ps;
344 	atomic_t num_mcast_sta; /* number of stations receiving multicast */
345 
346 	bool multicast_to_unicast;
347 	bool active;
348 };
349 
350 struct ieee80211_if_vlan {
351 	struct list_head list; /* write-protected with RTNL and local->mtx */
352 
353 	/* used for all tx if the VLAN is configured to 4-addr mode */
354 	struct sta_info __rcu *sta;
355 	atomic_t num_mcast_sta; /* number of stations receiving multicast */
356 };
357 
358 struct mesh_stats {
359 	__u32 fwded_mcast;		/* Mesh forwarded multicast frames */
360 	__u32 fwded_unicast;		/* Mesh forwarded unicast frames */
361 	__u32 fwded_frames;		/* Mesh total forwarded frames */
362 	__u32 dropped_frames_ttl;	/* Not transmitted since mesh_ttl == 0*/
363 	__u32 dropped_frames_no_route;	/* Not transmitted, no route found */
364 };
365 
366 #define PREQ_Q_F_START		0x1
367 #define PREQ_Q_F_REFRESH	0x2
368 struct mesh_preq_queue {
369 	struct list_head list;
370 	u8 dst[ETH_ALEN];
371 	u8 flags;
372 };
373 
374 struct ieee80211_roc_work {
375 	struct list_head list;
376 
377 	struct ieee80211_sub_if_data *sdata;
378 
379 	struct ieee80211_channel *chan;
380 
381 	bool started, abort, hw_begun, notified;
382 	bool on_channel;
383 
384 	unsigned long start_time;
385 
386 	u32 duration, req_duration;
387 	struct sk_buff *frame;
388 	u64 cookie, mgmt_tx_cookie;
389 	enum ieee80211_roc_type type;
390 };
391 
392 /* flags used in struct ieee80211_if_managed.flags */
393 enum ieee80211_sta_flags {
394 	IEEE80211_STA_CONNECTION_POLL	= BIT(1),
395 	IEEE80211_STA_CONTROL_PORT	= BIT(2),
396 	IEEE80211_STA_MFP_ENABLED	= BIT(6),
397 	IEEE80211_STA_UAPSD_ENABLED	= BIT(7),
398 	IEEE80211_STA_NULLFUNC_ACKED	= BIT(8),
399 	IEEE80211_STA_ENABLE_RRM	= BIT(15),
400 };
401 
402 enum ieee80211_conn_mode {
403 	IEEE80211_CONN_MODE_S1G,
404 	IEEE80211_CONN_MODE_LEGACY,
405 	IEEE80211_CONN_MODE_HT,
406 	IEEE80211_CONN_MODE_VHT,
407 	IEEE80211_CONN_MODE_HE,
408 	IEEE80211_CONN_MODE_EHT,
409 	IEEE80211_CONN_MODE_UHR,
410 };
411 
412 #define IEEE80211_CONN_MODE_HIGHEST	IEEE80211_CONN_MODE_UHR
413 
414 enum ieee80211_conn_bw_limit {
415 	IEEE80211_CONN_BW_LIMIT_20,
416 	IEEE80211_CONN_BW_LIMIT_40,
417 	IEEE80211_CONN_BW_LIMIT_80,
418 	IEEE80211_CONN_BW_LIMIT_160, /* also 80+80 */
419 	IEEE80211_CONN_BW_LIMIT_320,
420 };
421 
422 struct ieee80211_conn_settings {
423 	enum ieee80211_conn_mode mode;
424 	enum ieee80211_conn_bw_limit bw_limit;
425 	bool dbe_enabled;
426 };
427 
428 extern const struct ieee80211_conn_settings ieee80211_conn_settings_unlimited;
429 
430 struct ieee80211_mgd_auth_data {
431 	struct cfg80211_bss *bss;
432 	unsigned long timeout;
433 	int tries;
434 	u16 algorithm, expected_transaction;
435 
436 	unsigned long userspace_selectors[BITS_TO_LONGS(128)];
437 
438 	u8 key[WLAN_KEY_LEN_WEP104];
439 	u8 key_len, key_idx;
440 	bool done, waiting;
441 	bool peer_confirmed;
442 	bool timeout_started;
443 	int link_id;
444 
445 	u8 ap_addr[ETH_ALEN] __aligned(2);
446 
447 	u16 trans, status;
448 	size_t data_len;
449 	u8 data[];
450 };
451 
452 struct ieee80211_mgd_assoc_data {
453 	struct {
454 		struct cfg80211_bss *bss;
455 
456 		u8 addr[ETH_ALEN] __aligned(2);
457 
458 		u8 ap_ht_param;
459 
460 		struct ieee80211_vht_cap ap_vht_cap;
461 
462 		size_t elems_len;
463 		u8 *elems; /* pointing to inside ie[] below */
464 
465 		struct ieee80211_conn_settings conn;
466 
467 		u16 status;
468 	} link[IEEE80211_MLD_MAX_NUM_LINKS];
469 
470 	u8 ap_addr[ETH_ALEN] __aligned(2);
471 
472 	/* this is for a workaround, so we use it only for non-MLO */
473 	const u8 *supp_rates;
474 	u8 supp_rates_len;
475 
476 	unsigned long timeout;
477 	int tries;
478 
479 	u8 prev_ap_addr[ETH_ALEN];
480 	u8 ssid[IEEE80211_MAX_SSID_LEN];
481 	u8 ssid_len;
482 	bool wmm, uapsd;
483 	bool need_beacon;
484 	bool synced;
485 	bool timeout_started;
486 	bool comeback; /* whether the AP has requested association comeback */
487 	bool s1g;
488 	bool spp_amsdu;
489 	bool cip;
490 	bool protected_twt;
491 
492 	s8 assoc_link_id;
493 
494 	__le16 ext_mld_capa_ops;
495 
496 	u8 fils_nonces[2 * FILS_NONCE_LEN];
497 	u8 fils_kek[FILS_MAX_KEK_LEN];
498 	size_t fils_kek_len;
499 
500 	size_t ie_len;
501 	u8 *ie_pos; /* used to fill ie[] with link[].elems */
502 	u8 ie[];
503 };
504 
505 struct ieee80211_sta_tx_tspec {
506 	/* timestamp of the first packet in the time slice */
507 	unsigned long time_slice_start;
508 
509 	u32 admitted_time; /* in usecs, unlike over the air */
510 	u8 tsid;
511 	s8 up; /* signed to be able to invalidate with -1 during teardown */
512 
513 	/* consumed TX time in microseconds in the time slice */
514 	u32 consumed_tx_time;
515 	enum {
516 		TX_TSPEC_ACTION_NONE = 0,
517 		TX_TSPEC_ACTION_DOWNGRADE,
518 		TX_TSPEC_ACTION_STOP_DOWNGRADE,
519 	} action;
520 	bool downgraded;
521 };
522 
523 /* Advertised TID-to-link mapping info */
524 struct ieee80211_adv_ttlm_info {
525 	/* time in TUs at which the new mapping is established, or 0 if there is
526 	 * no planned advertised TID-to-link mapping
527 	 */
528 	u16 switch_time;
529 	u32 duration; /* duration of the planned T2L map in TUs */
530 	u16 map; /* map of usable links for all TIDs */
531 	bool active; /* whether the advertised mapping is active or not */
532 };
533 
534 DECLARE_EWMA(beacon_signal, 4, 4)
535 
536 struct ieee80211_if_managed {
537 	struct timer_list timer;
538 	struct timer_list conn_mon_timer;
539 	struct timer_list bcn_mon_timer;
540 	struct wiphy_work monitor_work;
541 	struct wiphy_work beacon_connection_loss_work;
542 	struct wiphy_work csa_connection_drop_work;
543 
544 	unsigned long beacon_timeout;
545 	unsigned long probe_timeout;
546 	int probe_send_count;
547 	bool nullfunc_failed;
548 	u8 connection_loss:1,
549 	   driver_disconnect:1,
550 	   reconnect:1,
551 	   associated:1;
552 
553 	struct ieee80211_mgd_auth_data *auth_data;
554 	struct ieee80211_mgd_assoc_data *assoc_data;
555 
556 	unsigned long userspace_selectors[BITS_TO_LONGS(128)];
557 
558 	bool powersave; /* powersave requested for this iface */
559 	bool broken_ap; /* AP is broken -- turn off powersave */
560 
561 	unsigned int flags;
562 
563 	u16 mcast_seq_last;
564 
565 	bool status_acked;
566 	bool status_received;
567 	__le16 status_fc;
568 
569 	enum {
570 		IEEE80211_MFP_DISABLED,
571 		IEEE80211_MFP_OPTIONAL,
572 		IEEE80211_MFP_REQUIRED
573 	} mfp; /* management frame protection */
574 
575 	/*
576 	 * Bitmask of enabled u-apsd queues,
577 	 * IEEE80211_WMM_IE_STA_QOSINFO_AC_BE & co. Needs a new association
578 	 * to take effect.
579 	 */
580 	unsigned int uapsd_queues;
581 
582 	/*
583 	 * Maximum number of buffered frames AP can deliver during a
584 	 * service period, IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL or similar.
585 	 * Needs a new association to take effect.
586 	 */
587 	unsigned int uapsd_max_sp_len;
588 
589 	u8 use_4addr;
590 
591 	/*
592 	 * State variables for keeping track of RSSI of the AP currently
593 	 * connected to and informing driver when RSSI has gone
594 	 * below/above a certain threshold.
595 	 */
596 	int rssi_min_thold, rssi_max_thold;
597 
598 	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
599 	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
600 	struct ieee80211_vht_cap vht_capa; /* configured VHT overrides */
601 	struct ieee80211_vht_cap vht_capa_mask; /* Valid parts of vht_capa */
602 	struct ieee80211_s1g_cap s1g_capa; /* configured S1G overrides */
603 	struct ieee80211_s1g_cap s1g_capa_mask; /* valid s1g_capa bits */
604 
605 	/* TDLS support */
606 	u8 tdls_peer[ETH_ALEN] __aligned(2);
607 	struct wiphy_delayed_work tdls_peer_del_work;
608 	struct sk_buff *orig_teardown_skb; /* The original teardown skb */
609 	struct sk_buff *teardown_skb; /* A copy to send through the AP */
610 	spinlock_t teardown_lock; /* To lock changing teardown_skb */
611 	bool tdls_wider_bw_prohibited;
612 
613 	/* WMM-AC TSPEC support */
614 	struct ieee80211_sta_tx_tspec tx_tspec[IEEE80211_NUM_ACS];
615 	/* Use a separate work struct so that we can do something here
616 	 * while the sdata->work is flushing the queues, for example.
617 	 * otherwise, in scenarios where we hardly get any traffic out
618 	 * on the BE queue, but there's a lot of VO traffic, we might
619 	 * get stuck in a downgraded situation and flush takes forever.
620 	 */
621 	struct wiphy_delayed_work tx_tspec_wk;
622 
623 	/* Information elements from the last transmitted (Re)Association
624 	 * Request frame.
625 	 */
626 	u8 *assoc_req_ies;
627 	size_t assoc_req_ies_len;
628 
629 	struct wiphy_hrtimer_work ml_reconf_work;
630 	u16 removed_links;
631 
632 	/* TID-to-link mapping support */
633 	struct wiphy_hrtimer_work ttlm_work;
634 	struct ieee80211_adv_ttlm_info ttlm_info;
635 	struct wiphy_work teardown_ttlm_work;
636 
637 	/* dialog token enumerator for neg TTLM request */
638 	u8 dialog_token_alloc;
639 	struct wiphy_delayed_work neg_ttlm_timeout_work;
640 
641 	/* Locally initiated multi-link reconfiguration */
642 	struct {
643 		struct ieee80211_mgd_assoc_data *add_links_data;
644 		struct wiphy_delayed_work wk;
645 		u16 removed_links;
646 		u16 added_links;
647 		u8 dialog_token;
648 	} reconf;
649 
650 	/* Support for epcs */
651 	struct {
652 		bool enabled;
653 		u8 dialog_token;
654 	} epcs;
655 
656 	struct {
657 		struct wiphy_hrtimer_work status_work;
658 		u32 timeout_us;
659 		u16 links;
660 		u16 pending, pending_init;
661 		u8 dialog_token;
662 		bool acked;
663 	} uhr_omp;
664 };
665 
666 struct ieee80211_if_ibss {
667 	struct timer_list timer;
668 	struct wiphy_work csa_connection_drop_work;
669 
670 	unsigned long last_scan_completed;
671 
672 	u32 basic_rates;
673 
674 	bool fixed_bssid;
675 	bool fixed_channel;
676 	bool privacy;
677 
678 	bool control_port;
679 	bool userspace_handles_dfs;
680 
681 	u8 bssid[ETH_ALEN] __aligned(2);
682 	u8 ssid[IEEE80211_MAX_SSID_LEN];
683 	u8 ssid_len, ie_len;
684 	u8 *ie;
685 	struct cfg80211_chan_def chandef;
686 
687 	unsigned long ibss_join_req;
688 	/* probe response/beacon for IBSS */
689 	struct beacon_data __rcu *presp;
690 
691 	struct ieee80211_ht_cap ht_capa; /* configured ht-cap over-rides */
692 	struct ieee80211_ht_cap ht_capa_mask; /* Valid parts of ht_capa */
693 
694 	spinlock_t incomplete_lock;
695 	struct list_head incomplete_stations;
696 	atomic_t incomplete_sta_count;
697 
698 	enum {
699 		IEEE80211_IBSS_MLME_SEARCH,
700 		IEEE80211_IBSS_MLME_JOINED,
701 	} state;
702 };
703 
704 /**
705  * struct ieee80211_if_ocb - OCB mode state
706  *
707  * @housekeeping_timer: timer for periodic invocation of a housekeeping task
708  * @wrkq_flags: OCB deferred task action
709  * @incomplete_lock: delayed STA insertion lock
710  * @incomplete_stations: list of STAs waiting for delayed insertion
711  * @incomplete_sta_count: pending entries and reserved allocations
712  * @joined: indication if the interface is connected to an OCB network
713  */
714 struct ieee80211_if_ocb {
715 	struct timer_list housekeeping_timer;
716 	unsigned long wrkq_flags;
717 
718 	spinlock_t incomplete_lock;
719 	struct list_head incomplete_stations;
720 	atomic_t incomplete_sta_count;
721 
722 	bool joined;
723 };
724 
725 /**
726  * struct ieee80211_mesh_sync_ops - Extensible synchronization framework interface
727  *
728  * these declarations define the interface, which enables
729  * vendor-specific mesh synchronization
730  *
731  * @rx_bcn_presp: beacon/probe response was received
732  * @adjust_tsf: TSF adjustment method
733  */
734 struct ieee80211_mesh_sync_ops {
735 	void (*rx_bcn_presp)(struct ieee80211_sub_if_data *sdata, u16 stype,
736 			     struct ieee80211_mgmt *mgmt, unsigned int len,
737 			     const struct ieee80211_meshconf_ie *mesh_cfg,
738 			     struct ieee80211_rx_status *rx_status);
739 
740 	/* should be called with beacon_data under RCU read lock */
741 	void (*adjust_tsf)(struct ieee80211_sub_if_data *sdata,
742 			   struct beacon_data *beacon);
743 	/* add other framework functions here */
744 };
745 
746 struct mesh_csa_settings {
747 	struct rcu_head rcu_head;
748 	struct cfg80211_csa_settings settings;
749 };
750 
751 /**
752  * struct mesh_table - mesh hash table
753  *
754  * @known_gates: list of known mesh gates and their mpaths by the station. The
755  * gate's mpath may or may not be resolved and active.
756  * @gates_lock: protects updates to known_gates
757  * @rhead: the rhashtable containing struct mesh_paths, keyed by dest addr
758  * @walk_head: linked list containing all mesh_path objects
759  * @walk_lock: lock protecting walk_head
760  * @entries: number of entries in the table
761  */
762 struct mesh_table {
763 	struct hlist_head known_gates;
764 	spinlock_t gates_lock;
765 	struct rhashtable rhead;
766 	struct hlist_head walk_head;
767 	spinlock_t walk_lock;
768 	atomic_t entries;		/* Up to MAX_MESH_NEIGHBOURS */
769 };
770 
771 /**
772  * struct mesh_tx_cache - mesh fast xmit header cache
773  *
774  * @rht: hash table containing struct ieee80211_mesh_fast_tx, using skb DA as key
775  * @walk_head: linked list containing all ieee80211_mesh_fast_tx objects
776  * @walk_lock: lock protecting walk_head and rht
777  */
778 struct mesh_tx_cache {
779 	struct rhashtable rht;
780 	struct hlist_head walk_head;
781 	spinlock_t walk_lock;
782 };
783 
784 struct ieee80211_if_mesh {
785 	struct timer_list housekeeping_timer;
786 	struct timer_list mesh_path_timer;
787 	struct timer_list mesh_path_root_timer;
788 
789 	unsigned long wrkq_flags;
790 	unsigned long mbss_changed[64 / BITS_PER_LONG];
791 
792 	bool userspace_handles_dfs;
793 
794 	u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];
795 	size_t mesh_id_len;
796 	/* Active Path Selection Protocol Identifier */
797 	u8 mesh_pp_id;
798 	/* Active Path Selection Metric Identifier */
799 	u8 mesh_pm_id;
800 	/* Congestion Control Mode Identifier */
801 	u8 mesh_cc_id;
802 	/* Synchronization Protocol Identifier */
803 	u8 mesh_sp_id;
804 	/* Authentication Protocol Identifier */
805 	u8 mesh_auth_id;
806 	/* Local mesh Sequence Number */
807 	u32 sn;
808 	/* Last used PREQ ID */
809 	u32 preq_id;
810 	atomic_t mpaths;
811 	/* Timestamp of last SN update */
812 	unsigned long last_sn_update;
813 	/* Time when it's ok to send next PERR */
814 	unsigned long next_perr;
815 	/* Timestamp of last PREQ sent */
816 	unsigned long last_preq;
817 	struct mesh_rmc *rmc;
818 	spinlock_t mesh_preq_queue_lock;
819 	struct mesh_preq_queue preq_queue;
820 	int preq_queue_len;
821 	struct mesh_stats mshstats;
822 	struct mesh_config mshcfg;
823 	atomic_t estab_plinks;
824 	atomic_t mesh_seqnum;
825 	bool accepting_plinks;
826 	int num_gates;
827 	struct beacon_data __rcu *beacon;
828 	const u8 *ie;
829 	u8 ie_len;
830 	enum {
831 		IEEE80211_MESH_SEC_NONE = 0x0,
832 		IEEE80211_MESH_SEC_AUTHED = 0x1,
833 		IEEE80211_MESH_SEC_SECURED = 0x2,
834 	} security;
835 	bool user_mpm;
836 	/* Extensible Synchronization Framework */
837 	const struct ieee80211_mesh_sync_ops *sync_ops;
838 	s64 sync_offset_clockdrift_max;
839 	spinlock_t sync_offset_lock;
840 	/* mesh power save */
841 	enum nl80211_mesh_power_mode nonpeer_pm;
842 	int ps_peers_light_sleep;
843 	int ps_peers_deep_sleep;
844 	struct ps_data ps;
845 	/* Channel Switching Support */
846 	struct mesh_csa_settings __rcu *csa;
847 	enum {
848 		IEEE80211_MESH_CSA_ROLE_NONE,
849 		IEEE80211_MESH_CSA_ROLE_INIT,
850 		IEEE80211_MESH_CSA_ROLE_REPEATER,
851 	} csa_role;
852 	u8 chsw_ttl;
853 	u16 pre_value;
854 
855 	/* offset from skb->data while building IE */
856 	int meshconf_offset;
857 
858 	struct mesh_table mesh_paths;
859 	struct mesh_table mpp_paths; /* Store paths for MPP&MAP */
860 	int mesh_paths_generation;
861 	int mpp_paths_generation;
862 	struct mesh_tx_cache tx_cache;
863 };
864 
865 #ifdef CONFIG_MAC80211_MESH
866 #define IEEE80211_IFSTA_MESH_CTR_INC(msh, name)	\
867 	do { (msh)->mshstats.name++; } while (0)
868 #else
869 #define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
870 	do { } while (0)
871 #endif
872 
873 /**
874  * enum ieee80211_sub_if_data_flags - virtual interface flags
875  *
876  * @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets
877  * @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between
878  *	associated stations and deliver multicast frames both
879  *	back to wireless media and to the local net stack.
880  * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
881  * @IEEE80211_SDATA_IN_DRIVER: indicates interface was added to driver
882  * @IEEE80211_SDATA_DISCONNECT_HW_RESTART: Disconnect after hardware restart
883  *  recovery
884  */
885 enum ieee80211_sub_if_data_flags {
886 	IEEE80211_SDATA_ALLMULTI		= BIT(0),
887 	IEEE80211_SDATA_DONT_BRIDGE_PACKETS	= BIT(3),
888 	IEEE80211_SDATA_DISCONNECT_RESUME	= BIT(4),
889 	IEEE80211_SDATA_IN_DRIVER		= BIT(5),
890 	IEEE80211_SDATA_DISCONNECT_HW_RESTART	= BIT(6),
891 };
892 
893 /**
894  * enum ieee80211_sdata_state_bits - virtual interface state bits
895  * @SDATA_STATE_RUNNING: virtual interface is up & running; this
896  *	mirrors netif_running() but is separate for interface type
897  *	change handling while the interface is up
898  * @SDATA_STATE_OFFCHANNEL: This interface is currently in offchannel
899  *	mode, so queues are stopped
900  * @SDATA_STATE_OFFCHANNEL_BEACON_STOPPED: Beaconing was stopped due
901  *	to offchannel, reset when offchannel returns
902  */
903 enum ieee80211_sdata_state_bits {
904 	SDATA_STATE_RUNNING,
905 	SDATA_STATE_OFFCHANNEL,
906 	SDATA_STATE_OFFCHANNEL_BEACON_STOPPED,
907 };
908 
909 /**
910  * enum ieee80211_chanctx_mode - channel context configuration mode
911  *
912  * @IEEE80211_CHANCTX_SHARED: channel context may be used by
913  *	multiple interfaces
914  * @IEEE80211_CHANCTX_EXCLUSIVE: channel context can be used
915  *	only by a single interface. This can be used for example for
916  *	non-fixed channel IBSS.
917  */
918 enum ieee80211_chanctx_mode {
919 	IEEE80211_CHANCTX_SHARED,
920 	IEEE80211_CHANCTX_EXCLUSIVE
921 };
922 
923 /**
924  * enum ieee80211_chanctx_replace_state - channel context replacement state
925  *
926  * This is used for channel context in-place reservations that require channel
927  * context switch/swap.
928  *
929  * @IEEE80211_CHANCTX_REPLACE_NONE: no replacement is taking place
930  * @IEEE80211_CHANCTX_WILL_BE_REPLACED: this channel context will be replaced
931  *	by a (not yet registered) channel context pointed by %replace_ctx.
932  * @IEEE80211_CHANCTX_REPLACES_OTHER: this (not yet registered) channel context
933  *	replaces an existing channel context pointed to by %replace_ctx.
934  */
935 enum ieee80211_chanctx_replace_state {
936 	IEEE80211_CHANCTX_REPLACE_NONE,
937 	IEEE80211_CHANCTX_WILL_BE_REPLACED,
938 	IEEE80211_CHANCTX_REPLACES_OTHER,
939 };
940 
941 struct ieee80211_chanctx {
942 	struct list_head list;
943 	struct rcu_head rcu_head;
944 
945 	enum ieee80211_chanctx_replace_state replace_state;
946 	struct ieee80211_chanctx *replace_ctx;
947 
948 	enum ieee80211_chanctx_mode mode;
949 	bool driver_present;
950 
951 	/* temporary data for search algorithm etc. */
952 	struct ieee80211_chan_req req;
953 
954 	bool radar_detected;
955 
956 	/* This chanctx is in process of getting used */
957 	bool will_be_used;
958 
959 	/* MUST be last - ends in a flexible-array member. */
960 	struct ieee80211_chanctx_conf conf;
961 };
962 
963 struct mac80211_qos_map {
964 	struct cfg80211_qos_map qos_map;
965 	struct rcu_head rcu_head;
966 };
967 
968 enum txq_info_flags {
969 	IEEE80211_TXQ_STOP,
970 	IEEE80211_TXQ_AMPDU,
971 	IEEE80211_TXQ_NO_AMSDU,
972 	IEEE80211_TXQ_DIRTY,
973 };
974 
975 /**
976  * struct txq_info - per tid queue
977  *
978  * @tin: contains packets split into multiple flows
979  * @def_cvars: codel vars for the @tin's default_flow
980  * @cstats: code statistics for this queue
981  * @frags: used to keep fragments created after dequeue
982  * @schedule_order: used with ieee80211_local->active_txqs
983  * @schedule_round: counter to prevent infinite loops on TXQ scheduling
984  * @flags: TXQ flags from &enum txq_info_flags
985  * @txq: the driver visible part
986  */
987 struct txq_info {
988 	struct fq_tin tin;
989 	struct codel_vars def_cvars;
990 	struct codel_stats cstats;
991 
992 	u16 schedule_round;
993 	struct list_head schedule_order;
994 
995 	struct sk_buff_head frags;
996 
997 	unsigned long flags;
998 
999 	/* keep last! */
1000 	struct ieee80211_txq txq;
1001 };
1002 
1003 struct ieee80211_if_mntr {
1004 	u32 flags;
1005 	u8 mu_follow_addr[ETH_ALEN] __aligned(2);
1006 
1007 	struct list_head list;
1008 };
1009 
1010 /**
1011  * struct ieee80211_if_nan - NAN state
1012  *
1013  * @conf: current NAN configuration
1014  * @started: true iff NAN is started
1015  * @de: Discovery Engine state (only valid if !WIPHY_NAN_FLAGS_USERSPACE_DE)
1016  * @de.func_lock: lock for @de.function_inst_ids
1017  * @de.function_inst_ids: a bitmap of available instance_id's
1018  * @removed_channels: bitmap of channels that should be removed from the NAN
1019  *	schedule once the deferred schedule update is completed.
1020  */
1021 struct ieee80211_if_nan {
1022 	struct cfg80211_nan_conf conf;
1023 	bool started;
1024 
1025 	struct {
1026 		/* protects function_inst_ids */
1027 		spinlock_t func_lock;
1028 		struct idr function_inst_ids;
1029 	} de;
1030 
1031 	DECLARE_BITMAP(removed_channels, IEEE80211_NAN_MAX_CHANNELS);
1032 };
1033 
1034 /**
1035  * struct ieee80211_if_nan_data - NAN data path state
1036  *
1037  * @nmi: pointer to the NAN management interface sdata. Used for data path,
1038  *	hence RCU.
1039  */
1040 struct ieee80211_if_nan_data {
1041 	struct ieee80211_sub_if_data __rcu *nmi;
1042 };
1043 
1044 struct ieee80211_link_data_managed {
1045 	u8 bssid[ETH_ALEN] __aligned(2);
1046 
1047 	u8 dtim_period;
1048 	enum ieee80211_smps_mode req_smps, /* requested smps mode */
1049 				 driver_smps_mode; /* smps mode request */
1050 
1051 	struct ieee80211_conn_settings conn;
1052 
1053 	s16 p2p_noa_index;
1054 
1055 	bool tdls_chan_switch_prohibited;
1056 
1057 	bool have_beacon;
1058 	bool tracking_signal_avg;
1059 	bool disable_wmm_tracking;
1060 	bool operating_11g_mode;
1061 
1062 	struct {
1063 		struct wiphy_hrtimer_work switch_work;
1064 		struct cfg80211_chan_def ap_chandef;
1065 		struct ieee80211_parsed_tpe tpe;
1066 		ktime_t time;
1067 		bool waiting_bcn;
1068 		bool ignored_same_chan;
1069 		bool blocked_tx;
1070 	} csa;
1071 
1072 	struct wiphy_work request_smps_work;
1073 	/* used to reconfigure hardware SM PS */
1074 	struct wiphy_work recalc_smps;
1075 
1076 	bool beacon_crc_valid;
1077 	u32 beacon_crc;
1078 	struct ewma_beacon_signal ave_beacon_signal;
1079 	int last_ave_beacon_signal;
1080 
1081 	/*
1082 	 * Number of Beacon frames used in ave_beacon_signal. This can be used
1083 	 * to avoid generating less reliable cqm events that would be based
1084 	 * only on couple of received frames.
1085 	 */
1086 	unsigned int count_beacon_signal;
1087 
1088 	/* Number of times beacon loss was invoked. */
1089 	unsigned int beacon_loss_count;
1090 
1091 	/*
1092 	 * Last Beacon frame signal strength average (ave_beacon_signal / 16)
1093 	 * that triggered a cqm event. 0 indicates that no event has been
1094 	 * generated for the current association.
1095 	 */
1096 	int last_cqm_event_signal;
1097 
1098 	int wmm_last_param_set;
1099 	int mu_edca_last_param_set;
1100 };
1101 
1102 struct ieee80211_link_data_ap {
1103 	struct beacon_data __rcu *beacon;
1104 	struct probe_resp __rcu *probe_resp;
1105 	struct fils_discovery_data __rcu *fils_discovery;
1106 	struct unsol_bcast_probe_resp_data __rcu *unsol_bcast_probe_resp;
1107 	struct s1g_short_beacon_data __rcu *s1g_short_beacon;
1108 
1109 	bool bss_update_in_progress;
1110 
1111 	/* to be used after channel switch. */
1112 	struct cfg80211_beacon_data *next_beacon;
1113 };
1114 
1115 struct ieee80211_link_data {
1116 	struct ieee80211_sub_if_data *sdata;
1117 	unsigned int link_id;
1118 
1119 	/* multicast keys only */
1120 	struct ieee80211_key __rcu *gtk[NUM_DEFAULT_KEYS +
1121 					NUM_DEFAULT_MGMT_KEYS +
1122 					NUM_DEFAULT_BEACON_KEYS];
1123 	struct ieee80211_key __rcu *cigtk[NUM_CTRL_KEYS];
1124 	struct ieee80211_key __rcu *default_multicast_key;
1125 	struct ieee80211_key __rcu *default_mgmt_key;
1126 	struct ieee80211_key __rcu *default_beacon_key;
1127 
1128 
1129 	bool operating_11g_mode;
1130 
1131 	struct {
1132 		struct wiphy_work finalize_work;
1133 		struct ieee80211_chan_req chanreq;
1134 	} csa;
1135 
1136 	struct wiphy_work color_change_finalize_work;
1137 	struct wiphy_delayed_work color_collision_detect_work;
1138 	u64 color_bitmap;
1139 
1140 	/* context reservation -- protected with wiphy mutex */
1141 	struct ieee80211_chanctx *reserved_chanctx;
1142 	struct ieee80211_chan_req reserved;
1143 	bool reserved_radar_required;
1144 	bool reserved_ready;
1145 
1146 	u8 needed_rx_chains;
1147 	enum ieee80211_smps_mode smps_mode;
1148 
1149 	int user_power_level; /* in dBm */
1150 	int ap_power_level; /* in dBm */
1151 
1152 	bool radar_required;
1153 	struct wiphy_hrtimer_work dfs_cac_timer_work;
1154 
1155 	union {
1156 		struct ieee80211_link_data_managed mgd;
1157 		struct ieee80211_link_data_ap ap;
1158 	} u;
1159 
1160 	/* protects replacing the u.ap template pointers, also without wiphy mutex */
1161 	spinlock_t ap_tmpl_lock;
1162 
1163 	struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
1164 
1165 	struct ieee80211_bss_conf *conf;
1166 
1167 	struct {
1168 		enum ieee80211_sta_rx_bandwidth he_and_lower;
1169 		enum ieee80211_sta_rx_bandwidth eht; /* and UHR non-DBE */
1170 	} bss_bw;
1171 
1172 #ifdef CONFIG_MAC80211_DEBUGFS
1173 	struct dentry *debugfs_dir;
1174 #endif
1175 };
1176 
1177 #define ap_tmpl_dereference(link, p)					\
1178 	rcu_dereference_protected(p, lockdep_is_held(&(link)->ap_tmpl_lock))
1179 
1180 #define ap_tmpl_replace(link, p, new)					\
1181 do {									\
1182 	typeof(ap_tmpl_dereference(link, p)) __old;			\
1183 									\
1184 	spin_lock(&(link)->ap_tmpl_lock);				\
1185 	__old = rcu_replace_pointer(p, new,				\
1186 				    lockdep_is_held(&(link)->ap_tmpl_lock));\
1187 	spin_unlock(&(link)->ap_tmpl_lock);				\
1188 	if (__old)							\
1189 		kfree_rcu(__old, rcu_head);				\
1190 } while (0)
1191 
1192 struct ieee80211_sub_if_data {
1193 	struct list_head list;
1194 
1195 	struct wireless_dev wdev;
1196 
1197 	/* keys */
1198 	struct list_head key_list;
1199 
1200 	/* count for keys needing tailroom space allocation */
1201 	int crypto_tx_tailroom_needed_cnt;
1202 	int crypto_tx_tailroom_pending_dec;
1203 	struct wiphy_delayed_work dec_tailroom_needed_wk;
1204 
1205 	struct net_device *dev;
1206 	struct ieee80211_local *local;
1207 
1208 	unsigned int flags;
1209 
1210 	unsigned long state;
1211 
1212 	char name[IFNAMSIZ];
1213 
1214 	struct ieee80211_fragment_cache frags;
1215 
1216 	/* TID bitmap for NoAck policy */
1217 	u16 noack_map;
1218 
1219 	/* bit field of ACM bits (BIT(802.1D tag)) */
1220 	u8 wmm_acm;
1221 
1222 	struct ieee80211_key __rcu *keys[NUM_DEFAULT_KEYS];
1223 	struct ieee80211_key __rcu *default_unicast_key;
1224 
1225 	u16 sequence_number;
1226 	u16 mld_mcast_seq;
1227 	__be16 control_port_protocol;
1228 	bool control_port_no_encrypt;
1229 	bool control_port_no_preauth;
1230 	bool control_port_over_nl80211;
1231 
1232 	atomic_t num_tx_queued;
1233 	struct mac80211_qos_map __rcu *qos_map;
1234 
1235 	struct wiphy_work work;
1236 	struct sk_buff_head skb_queue;
1237 	struct sk_buff_head status_queue;
1238 
1239 	/*
1240 	 * AP this belongs to: self in AP mode and
1241 	 * corresponding AP in VLAN mode, NULL for
1242 	 * all others (might be needed later in IBSS)
1243 	 */
1244 	struct ieee80211_if_ap *bss;
1245 
1246 	/* bitmap of allowed (non-MCS) rate indexes for rate control */
1247 	u32 rc_rateidx_mask[NUM_NL80211_BANDS];
1248 
1249 	bool rc_has_mcs_mask[NUM_NL80211_BANDS];
1250 	u8  rc_rateidx_mcs_mask[NUM_NL80211_BANDS][IEEE80211_HT_MCS_MASK_LEN];
1251 
1252 	bool rc_has_vht_mcs_mask[NUM_NL80211_BANDS];
1253 	u16 rc_rateidx_vht_mcs_mask[NUM_NL80211_BANDS][NL80211_VHT_NSS_MAX];
1254 
1255 	/* Beacon frame (non-MCS) rate (as a bitmap) */
1256 	u32 beacon_rateidx_mask[NUM_NL80211_BANDS];
1257 	bool beacon_rate_set;
1258 
1259 	union {
1260 		struct ieee80211_if_ap ap;
1261 		struct ieee80211_if_vlan vlan;
1262 		struct ieee80211_if_managed mgd;
1263 		struct ieee80211_if_ibss ibss;
1264 		struct ieee80211_if_mesh mesh;
1265 		struct ieee80211_if_ocb ocb;
1266 		struct ieee80211_if_mntr mntr;
1267 		struct ieee80211_if_nan nan;
1268 		struct ieee80211_if_nan_data nan_data;
1269 	} u;
1270 
1271 	struct ieee80211_link_data deflink;
1272 	struct ieee80211_link_data __rcu *link[IEEE80211_MLD_MAX_NUM_LINKS];
1273 
1274 	/* for ieee80211_set_active_links_async() */
1275 	struct wiphy_work activate_links_work;
1276 	u16 desired_active_links;
1277 
1278 	u16 restart_active_links;
1279 
1280 #ifdef CONFIG_MAC80211_DEBUGFS
1281 	struct {
1282 		struct dentry *subdir_stations;
1283 		struct dentry *default_unicast_key;
1284 		struct dentry *default_multicast_key;
1285 		struct dentry *default_mgmt_key;
1286 		struct dentry *default_beacon_key;
1287 	} debugfs;
1288 #endif
1289 
1290 	u32 tx_handlers_drop;
1291 	/* must be last, dynamically sized area in this! */
1292 	struct ieee80211_vif vif;
1293 };
1294 
1295 static inline
1296 struct ieee80211_sub_if_data *vif_to_sdata(struct ieee80211_vif *p)
1297 {
1298 	return container_of(p, struct ieee80211_sub_if_data, vif);
1299 }
1300 
1301 #define sdata_dereference(p, sdata) \
1302 	wiphy_dereference(sdata->local->hw.wiphy, p)
1303 
1304 #define for_each_sdata_link(_local, _link)				\
1305 	/* outer loop just to define the variables ... */		\
1306 	for (struct ieee80211_sub_if_data *___sdata = NULL;		\
1307 	     !___sdata;							\
1308 	     ___sdata = (void *)~0 /* always stop */)			\
1309 	for (int ___link_id = ARRAY_SIZE(___sdata->link);		\
1310 	     ___link_id; ___link_id = 0 /* always stop */)		\
1311 	list_for_each_entry(___sdata, &(_local)->interfaces, list)	\
1312 	if (___link_id == ARRAY_SIZE(___sdata->link) &&			\
1313 	    ieee80211_sdata_running(___sdata))				\
1314 	for (___link_id = 0;						\
1315 	     ___link_id < ARRAY_SIZE(___sdata->link);			\
1316 	     ___link_id++)						\
1317 	if ((_link = wiphy_dereference((_local)->hw.wiphy,		\
1318 				       ___sdata->link[___link_id])))
1319 
1320 /*
1321  * for_each_sdata_link_rcu() must be used under RCU read lock.
1322  */
1323 #define for_each_sdata_link_rcu(_local, _link)						\
1324 	/* outer loop just to define the variables ... */				\
1325 	for (struct ieee80211_sub_if_data *___sdata = NULL;				\
1326 	     !___sdata;									\
1327 	     ___sdata = (void *)~0 /* always stop */)					\
1328 	for (int ___link_id = ARRAY_SIZE(___sdata->link);		\
1329 	     ___link_id; ___link_id = 0 /* always stop */)		\
1330 	list_for_each_entry(___sdata, &(_local)->interfaces, list)	\
1331 	if (___link_id == ARRAY_SIZE(___sdata->link) &&			\
1332 	    ieee80211_sdata_running(___sdata))				\
1333 	for (___link_id = 0;						\
1334 	     ___link_id < ARRAY_SIZE((___sdata)->link);					\
1335 	     ___link_id++)								\
1336 	if ((_link = rcu_dereference((___sdata)->link[___link_id])))
1337 
1338 #define for_each_link_data(sdata, __link)					\
1339 	/* outer loop just to define the variable ... */			\
1340 	for (struct ieee80211_sub_if_data *__sdata = (sdata); __sdata;		\
1341 		__sdata = NULL /* always stop */)				\
1342 	for (int __link_id = 0;							\
1343 	     __link_id < ARRAY_SIZE((__sdata)->link); __link_id++)		\
1344 		if ((!(__sdata)->vif.valid_links ||				\
1345 		     (__sdata)->vif.valid_links & BIT(__link_id)) &&		\
1346 		    ((__link) = sdata_dereference((__sdata)->link[__link_id],	\
1347 						  (__sdata))))
1348 
1349 /*
1350  * for_each_link_data_rcu should be used under RCU read lock.
1351  */
1352 #define for_each_link_data_rcu(sdata, __link)					\
1353 	/* outer loop just to define the variable ... */			\
1354 	for (struct ieee80211_sub_if_data *__sdata = (sdata); __sdata;		\
1355 		__sdata = NULL /* always stop */)				\
1356 	for (int __link_id = 0;							\
1357 	     __link_id < ARRAY_SIZE((__sdata)->link); __link_id++)		\
1358 		if ((!(__sdata)->vif.valid_links ||				\
1359 		     (__sdata)->vif.valid_links & BIT(__link_id)) &&		\
1360 		    ((__link) = rcu_dereference((__sdata)->link[__link_id])))	\
1361 
1362 static inline int
1363 ieee80211_get_mbssid_beacon_len(struct cfg80211_mbssid_elems *elems,
1364 				struct cfg80211_rnr_elems *rnr_elems,
1365 				u8 i)
1366 {
1367 	int len = 0;
1368 
1369 	if (!elems || !elems->cnt || i > elems->cnt)
1370 		return 0;
1371 
1372 	if (i < elems->cnt) {
1373 		len = elems->elem[i].len;
1374 		if (rnr_elems) {
1375 			len += rnr_elems->elem[i].len;
1376 			for (i = elems->cnt; i < rnr_elems->cnt; i++)
1377 				len += rnr_elems->elem[i].len;
1378 		}
1379 		return len;
1380 	}
1381 
1382 	/* i == elems->cnt, calculate total length of all MBSSID elements */
1383 	for (i = 0; i < elems->cnt; i++)
1384 		len += elems->elem[i].len;
1385 
1386 	if (rnr_elems) {
1387 		for (i = 0; i < rnr_elems->cnt; i++)
1388 			len += rnr_elems->elem[i].len;
1389 	}
1390 
1391 	return len;
1392 }
1393 
1394 enum {
1395 	IEEE80211_RX_MSG	= 1,
1396 	IEEE80211_TX_STATUS_MSG	= 2,
1397 };
1398 
1399 enum queue_stop_reason {
1400 	IEEE80211_QUEUE_STOP_REASON_DRIVER,
1401 	IEEE80211_QUEUE_STOP_REASON_PS,
1402 	IEEE80211_QUEUE_STOP_REASON_CSA,
1403 	IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
1404 	IEEE80211_QUEUE_STOP_REASON_SUSPEND,
1405 	IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
1406 	IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL,
1407 	IEEE80211_QUEUE_STOP_REASON_FLUSH,
1408 	IEEE80211_QUEUE_STOP_REASON_TDLS_TEARDOWN,
1409 	IEEE80211_QUEUE_STOP_REASON_RESERVE_TID,
1410 	IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE,
1411 
1412 	IEEE80211_QUEUE_STOP_REASONS,
1413 };
1414 
1415 #ifdef CONFIG_MAC80211_LEDS
1416 struct tpt_led_trigger {
1417 	char name[32];
1418 	const struct ieee80211_tpt_blink *blink_table;
1419 	unsigned int blink_table_len;
1420 	struct timer_list timer;
1421 	struct ieee80211_local *local;
1422 	unsigned long prev_traffic;
1423 	unsigned long tx_bytes, rx_bytes;
1424 	unsigned int active, want;
1425 	bool running;
1426 };
1427 #endif
1428 
1429 /**
1430  * enum mac80211_scan_flags - currently active scan mode
1431  *
1432  * @SCAN_SW_SCANNING: We're currently in the process of scanning but may as
1433  *	well be on the operating channel
1434  * @SCAN_HW_SCANNING: The hardware is scanning for us, we have no way to
1435  *	determine if we are on the operating channel or not
1436  * @SCAN_ONCHANNEL_SCANNING:  Do a software scan on only the current operating
1437  *	channel. This should not interrupt normal traffic.
1438  * @SCAN_COMPLETED: Set for our scan work function when the driver reported
1439  *	that the scan completed.
1440  * @SCAN_ABORTED: Set for our scan work function when the driver reported
1441  *	a scan complete for an aborted scan.
1442  * @SCAN_HW_CANCELLED: Set for our scan work function when the scan is being
1443  *	cancelled.
1444  * @SCAN_BEACON_WAIT: Set whenever we're passive scanning because of radar/no-IR
1445  *	and could send a probe request after receiving a beacon.
1446  * @SCAN_BEACON_DONE: Beacon received, we can now send a probe request
1447  */
1448 enum mac80211_scan_flags {
1449 	SCAN_SW_SCANNING,
1450 	SCAN_HW_SCANNING,
1451 	SCAN_ONCHANNEL_SCANNING,
1452 	SCAN_COMPLETED,
1453 	SCAN_ABORTED,
1454 	SCAN_HW_CANCELLED,
1455 	SCAN_BEACON_WAIT,
1456 	SCAN_BEACON_DONE,
1457 };
1458 
1459 /**
1460  * enum mac80211_scan_state - scan state machine states
1461  *
1462  * @SCAN_DECISION: Main entry point to the scan state machine, this state
1463  *	determines if we should keep on scanning or switch back to the
1464  *	operating channel
1465  * @SCAN_SET_CHANNEL: Set the next channel to be scanned
1466  * @SCAN_SEND_PROBE: Send probe requests and wait for probe responses
1467  * @SCAN_SUSPEND: Suspend the scan and go back to operating channel to
1468  *	send out data
1469  * @SCAN_RESUME: Resume the scan and scan the next channel
1470  * @SCAN_ABORT: Abort the scan and go back to operating channel
1471  */
1472 enum mac80211_scan_state {
1473 	SCAN_DECISION,
1474 	SCAN_SET_CHANNEL,
1475 	SCAN_SEND_PROBE,
1476 	SCAN_SUSPEND,
1477 	SCAN_RESUME,
1478 	SCAN_ABORT,
1479 };
1480 
1481 DECLARE_STATIC_KEY_FALSE(aql_disable);
1482 
1483 struct ieee80211_local {
1484 	/* embed the driver visible part.
1485 	 * don't cast (use the static inlines below), but we keep
1486 	 * it first anyway so they become a no-op */
1487 	struct ieee80211_hw hw;
1488 
1489 	struct fq fq;
1490 	struct codel_vars *cvars;
1491 	struct codel_params cparams;
1492 
1493 	/* protects active_txqs and txqi->schedule_order */
1494 	spinlock_t active_txq_lock[IEEE80211_NUM_ACS];
1495 	struct list_head active_txqs[IEEE80211_NUM_ACS];
1496 	u16 schedule_round[IEEE80211_NUM_ACS];
1497 	bool schedule_open[IEEE80211_NUM_ACS];
1498 
1499 	/* serializes ieee80211_handle_wake_tx_queue */
1500 	spinlock_t handle_wake_tx_queue_lock;
1501 
1502 	u16 airtime_flags;
1503 	u32 aql_txq_limit_mc;
1504 	u32 aql_txq_limit_low[IEEE80211_NUM_ACS];
1505 	u32 aql_txq_limit_high[IEEE80211_NUM_ACS];
1506 	u32 aql_threshold;
1507 	atomic_t aql_total_pending_airtime;
1508 	atomic_t aql_mc_pending_airtime;
1509 	atomic_t aql_ac_pending_airtime[IEEE80211_NUM_ACS];
1510 
1511 	const struct ieee80211_ops *ops;
1512 
1513 	/*
1514 	 * private workqueue to mac80211. mac80211 makes this accessible
1515 	 * via ieee80211_queue_work()
1516 	 */
1517 	struct workqueue_struct *workqueue;
1518 
1519 	unsigned long queue_stop_reasons[IEEE80211_MAX_QUEUES];
1520 	int q_stop_reasons[IEEE80211_MAX_QUEUES][IEEE80211_QUEUE_STOP_REASONS];
1521 	/* also used to protect ampdu_ac_queue and amdpu_ac_stop_refcnt */
1522 	spinlock_t queue_stop_reason_lock;
1523 
1524 	int open_count;
1525 	int monitors, virt_monitors, tx_mntrs;
1526 	/* number of interfaces with corresponding FIF_ flags */
1527 	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss, fif_pspoll,
1528 	    fif_probe_req;
1529 	bool probe_req_reg;
1530 	bool rx_mcast_action_reg;
1531 	unsigned int filter_flags; /* FIF_* */
1532 
1533 	struct cfg80211_chan_def dflt_chandef;
1534 	bool emulate_chanctx;
1535 
1536 	/* protects the aggregated multicast list and filter calls */
1537 	spinlock_t filter_lock;
1538 
1539 	/* used for uploading changed mc list */
1540 	struct wiphy_work reconfig_filter;
1541 
1542 	/* aggregated multicast list */
1543 	struct netdev_hw_addr_list mc_list;
1544 
1545 	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
1546 
1547 	/*
1548 	 * suspended is true if we finished all the suspend _and_ we have
1549 	 * not yet come up from resume. This is to be used by mac80211
1550 	 * to ensure driver sanity during suspend and mac80211's own
1551 	 * sanity. It can eventually be used for WoW as well.
1552 	 */
1553 	bool suspended;
1554 
1555 	/* suspending is true during the whole suspend process */
1556 	bool suspending;
1557 
1558 	/*
1559 	 * Resuming is true while suspended, but when we're reprogramming the
1560 	 * hardware -- at that time it's allowed to use ieee80211_queue_work()
1561 	 * again even though some other parts of the stack are still suspended
1562 	 * and we still drop received frames to avoid waking the stack.
1563 	 */
1564 	bool resuming;
1565 
1566 	/*
1567 	 * quiescing is true during the suspend process _only_ to
1568 	 * ease timer cancelling etc.
1569 	 */
1570 	bool quiescing;
1571 
1572 	/* device is started */
1573 	bool started;
1574 
1575 	/* device is during a HW reconfig */
1576 	bool in_reconfig;
1577 
1578 	/* reconfiguration failed ... suppress some warnings etc. */
1579 	bool reconfig_failure;
1580 
1581 	/* wowlan is enabled -- don't reconfig on resume */
1582 	bool wowlan;
1583 
1584 	struct wiphy_work radar_detected_work;
1585 
1586 	/* number of RX chains the hardware has */
1587 	u8 rx_chains;
1588 
1589 	/* bitmap of which sbands were copied */
1590 	u8 sband_allocated;
1591 
1592 	int tx_headroom; /* required headroom for hardware/radiotap */
1593 
1594 	/* Tasklet and skb queue to process calls from IRQ mode. All frames
1595 	 * added to skb_queue will be processed, but frames in
1596 	 * skb_queue_unreliable may be dropped if the total length of these
1597 	 * queues increases over the limit. */
1598 #define IEEE80211_IRQSAFE_QUEUE_LIMIT 128
1599 	struct tasklet_struct tasklet;
1600 	struct sk_buff_head skb_queue;
1601 	struct sk_buff_head skb_queue_unreliable;
1602 
1603 	spinlock_t rx_path_lock;
1604 
1605 	/* Station data */
1606 	/*
1607 	 * The list, hash table and counter are protected
1608 	 * by the wiphy mutex, reads are done with RCU.
1609 	 */
1610 	spinlock_t tim_lock;
1611 	unsigned long num_sta;
1612 	struct list_head sta_list;
1613 	struct rhltable sta_hash;
1614 	struct rhltable link_sta_hash;
1615 	struct timer_list sta_cleanup;
1616 	int sta_generation;
1617 
1618 	struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
1619 	struct tasklet_struct tx_pending_tasklet;
1620 	struct tasklet_struct wake_txqs_tasklet;
1621 
1622 	atomic_t agg_queue_stop[IEEE80211_MAX_QUEUES];
1623 
1624 	/* number of interfaces with allmulti RX */
1625 	atomic_t iff_allmultis;
1626 
1627 	struct rate_control_ref *rate_ctrl;
1628 
1629 	struct arc4_ctx wep_tx_ctx;
1630 	struct arc4_ctx wep_rx_ctx;
1631 	u32 wep_iv;
1632 
1633 	/* see iface.c */
1634 	struct list_head interfaces;
1635 	struct list_head mon_list; /* only that are IFF_UP */
1636 	struct mutex iflist_mtx;
1637 
1638 	/* Scanning and BSS list */
1639 	unsigned long scanning;
1640 	struct cfg80211_ssid scan_ssid;
1641 	struct cfg80211_scan_request *int_scan_req;
1642 	struct cfg80211_scan_request __rcu *scan_req;
1643 	struct ieee80211_scan_request *hw_scan_req;
1644 	struct cfg80211_chan_def scan_chandef;
1645 	enum nl80211_band hw_scan_band;
1646 	int scan_channel_idx;
1647 	int scan_ies_len;
1648 	int hw_scan_ies_bufsize;
1649 	struct cfg80211_scan_info scan_info;
1650 
1651 	struct wiphy_work sched_scan_stopped_work;
1652 	struct ieee80211_sub_if_data __rcu *sched_scan_sdata;
1653 	struct cfg80211_sched_scan_request __rcu *sched_scan_req;
1654 	u8 scan_addr[ETH_ALEN];
1655 
1656 	unsigned long leave_oper_channel_time;
1657 	enum mac80211_scan_state next_scan_state;
1658 	struct wiphy_delayed_work scan_work;
1659 	struct ieee80211_sub_if_data __rcu *scan_sdata;
1660 
1661 	/* Temporary remain-on-channel for off-channel operations */
1662 	struct ieee80211_channel *tmp_channel;
1663 
1664 	/* channel contexts */
1665 	struct list_head chanctx_list;
1666 
1667 #ifdef CONFIG_MAC80211_LEDS
1668 	struct led_trigger tx_led, rx_led, assoc_led, radio_led;
1669 	struct led_trigger tpt_led;
1670 	atomic_t tx_led_active, rx_led_active, assoc_led_active;
1671 	atomic_t radio_led_active, tpt_led_active;
1672 	struct tpt_led_trigger *tpt_led_trigger;
1673 #endif
1674 
1675 #ifdef CONFIG_MAC80211_DEBUG_COUNTERS
1676 	/* SNMP counters */
1677 	/* dot11CountersTable */
1678 	u32 dot11TransmittedFragmentCount;
1679 	u32 dot11MulticastTransmittedFrameCount;
1680 	u32 dot11FailedCount;
1681 	u32 dot11RetryCount;
1682 	u32 dot11MultipleRetryCount;
1683 	u32 dot11FrameDuplicateCount;
1684 	u32 dot11ReceivedFragmentCount;
1685 	u32 dot11MulticastReceivedFrameCount;
1686 	u32 dot11TransmittedFrameCount;
1687 
1688 	/* TX/RX handler statistics */
1689 	unsigned int tx_handlers_queued;
1690 	unsigned int tx_handlers_drop_wep;
1691 	unsigned int tx_handlers_drop_not_assoc;
1692 	unsigned int tx_handlers_drop_unauth_port;
1693 	unsigned int rx_handlers_drop;
1694 	unsigned int rx_handlers_queued;
1695 	unsigned int rx_handlers_drop_nullfunc;
1696 	unsigned int rx_handlers_drop_defrag;
1697 	unsigned int tx_expand_skb_head;
1698 	unsigned int tx_expand_skb_head_cloned;
1699 	unsigned int rx_expand_skb_head_defrag;
1700 	unsigned int rx_handlers_fragments;
1701 	unsigned int tx_status_drop;
1702 #define I802_DEBUG_INC(c) (c)++
1703 #else /* CONFIG_MAC80211_DEBUG_COUNTERS */
1704 #define I802_DEBUG_INC(c) do { } while (0)
1705 #endif /* CONFIG_MAC80211_DEBUG_COUNTERS */
1706 
1707 
1708 	int total_ps_buffered; /* total number of all buffered unicast and
1709 				* multicast packets for power saving stations
1710 				*/
1711 
1712 	bool pspolling;
1713 	/*
1714 	 * PS can only be enabled when we have exactly one managed
1715 	 * interface (and monitors) in PS, this then points there.
1716 	 */
1717 	struct ieee80211_sub_if_data *ps_sdata;
1718 	struct wiphy_work dynamic_ps_enable_work;
1719 	struct wiphy_work dynamic_ps_disable_work;
1720 	struct timer_list dynamic_ps_timer;
1721 	struct notifier_block ifa_notifier;
1722 	struct notifier_block ifa6_notifier;
1723 
1724 	/*
1725 	 * The dynamic ps timeout configured from user space via WEXT -
1726 	 * this will override whatever chosen by mac80211 internally.
1727 	 */
1728 	int dynamic_ps_forced_timeout;
1729 
1730 	int user_power_level; /* in dBm, for all interfaces */
1731 
1732 	struct work_struct restart_work;
1733 
1734 #ifdef CONFIG_MAC80211_DEBUGFS
1735 	struct local_debugfsdentries {
1736 		struct dentry *rcdir;
1737 		struct dentry *keys;
1738 	} debugfs;
1739 	bool force_tx_status;
1740 #endif
1741 
1742 	/*
1743 	 * Remain-on-channel support
1744 	 */
1745 	struct wiphy_delayed_work roc_work;
1746 	struct list_head roc_list;
1747 	struct wiphy_work hw_roc_start, hw_roc_done;
1748 	unsigned long hw_roc_start_time;
1749 	struct idr ack_status_frames;
1750 	spinlock_t ack_status_lock;
1751 
1752 	/* virtual monitor interface */
1753 	struct ieee80211_sub_if_data __rcu *monitor_sdata;
1754 	struct ieee80211_chan_req monitor_chanreq;
1755 
1756 	/* extended capabilities provided by mac80211 */
1757 	u8 ext_capa[8];
1758 
1759 	bool wbrf_supported;
1760 };
1761 
1762 static inline struct ieee80211_sub_if_data *
1763 IEEE80211_DEV_TO_SUB_IF(const struct net_device *dev)
1764 {
1765 	return netdev_priv(dev);
1766 }
1767 
1768 static inline struct ieee80211_sub_if_data *
1769 IEEE80211_WDEV_TO_SUB_IF(struct wireless_dev *wdev)
1770 {
1771 	return container_of(wdev, struct ieee80211_sub_if_data, wdev);
1772 }
1773 
1774 static inline struct ieee80211_supported_band *
1775 ieee80211_get_sband(struct ieee80211_sub_if_data *sdata)
1776 {
1777 	struct ieee80211_local *local = sdata->local;
1778 	struct ieee80211_chanctx_conf *chanctx_conf;
1779 	enum nl80211_band band;
1780 
1781 	WARN_ON(ieee80211_vif_is_mld(&sdata->vif));
1782 
1783 	rcu_read_lock();
1784 	chanctx_conf = rcu_dereference(sdata->vif.bss_conf.chanctx_conf);
1785 
1786 	if (!chanctx_conf) {
1787 		rcu_read_unlock();
1788 		return NULL;
1789 	}
1790 
1791 	band = chanctx_conf->def.chan->band;
1792 	rcu_read_unlock();
1793 
1794 	return local->hw.wiphy->bands[band];
1795 }
1796 
1797 static inline struct ieee80211_supported_band *
1798 ieee80211_get_link_sband(struct ieee80211_link_data *link)
1799 {
1800 	struct ieee80211_local *local = link->sdata->local;
1801 	struct ieee80211_chanctx_conf *chanctx_conf;
1802 	enum nl80211_band band;
1803 
1804 	rcu_read_lock();
1805 	chanctx_conf = rcu_dereference(link->conf->chanctx_conf);
1806 	if (!chanctx_conf) {
1807 		rcu_read_unlock();
1808 		return NULL;
1809 	}
1810 
1811 	band = chanctx_conf->def.chan->band;
1812 	rcu_read_unlock();
1813 
1814 	return local->hw.wiphy->bands[band];
1815 }
1816 
1817 /* this struct holds the value parsing from channel switch IE  */
1818 struct ieee80211_csa_ie {
1819 	struct ieee80211_chan_req chanreq;
1820 	u8 mode;
1821 	u8 count;
1822 	u8 ttl;
1823 	u16 pre_value;
1824 	u16 reason_code;
1825 	u32 max_switch_time;
1826 };
1827 
1828 enum ieee80211_elems_parse_error {
1829 	IEEE80211_PARSE_ERR_INVALID_END		= BIT(0),
1830 	IEEE80211_PARSE_ERR_DUP_ELEM		= BIT(1),
1831 	IEEE80211_PARSE_ERR_BAD_ELEM_SIZE	= BIT(2),
1832 	IEEE80211_PARSE_ERR_UNEXPECTED_ELEM	= BIT(3),
1833 	IEEE80211_PARSE_ERR_DUP_NEST_ML_BASIC	= BIT(4),
1834 };
1835 
1836 /* Parsed Information Elements */
1837 struct ieee802_11_elems {
1838 	const u8 *ie_start;
1839 	size_t total_len;
1840 	u32 crc;
1841 	u8 frame_type;
1842 	bool from_ap;
1843 
1844 	/* pointers to IEs */
1845 	const struct ieee80211_tdls_lnkie *lnk_id;
1846 	const struct ieee80211_ch_switch_timing *ch_sw_timing;
1847 	const u8 *ext_capab;
1848 	const u8 *ssid;
1849 	const u8 *supp_rates;
1850 	const u8 *ds_params;
1851 	const struct ieee80211_tim_ie *tim;
1852 	const u8 *rsn;
1853 	const u8 *rsnx;
1854 	const u8 *erp_info;
1855 	const u8 *ext_supp_rates;
1856 	const u8 *wmm_info;
1857 	const u8 *wmm_param;
1858 	const struct ieee80211_ht_cap *ht_cap_elem;
1859 	const struct ieee80211_ht_operation *ht_operation;
1860 	const struct ieee80211_vht_cap *vht_cap_elem;
1861 	const struct ieee80211_vht_operation *vht_operation;
1862 	const struct ieee80211_meshconf_ie *mesh_config;
1863 	const u8 *he_cap;
1864 	const struct ieee80211_he_operation *he_operation;
1865 	const struct ieee80211_he_spr *he_spr;
1866 	const struct ieee80211_mu_edca_param_set *mu_edca_param_set;
1867 	const struct ieee80211_he_6ghz_capa *he_6ghz_capa;
1868 	const u8 *uora_element;
1869 	const u8 *mesh_id;
1870 	const u8 *peering;
1871 	const __le16 *awake_window;
1872 	const u8 *preq;
1873 	const u8 *prep;
1874 	const u8 *perr;
1875 	const struct ieee80211_rann_ie *rann;
1876 	const struct ieee80211_channel_sw_ie *ch_switch_ie;
1877 	const struct ieee80211_ext_chansw_ie *ext_chansw_ie;
1878 	const struct ieee80211_wide_bw_chansw_ie *wide_bw_chansw_ie;
1879 	const u8 *max_channel_switch_time;
1880 	const u8 *country_elem;
1881 	const u8 *pwr_constr_elem;
1882 	const u8 *cisco_dtpc_elem;
1883 	const struct ieee80211_timeout_interval_ie *timeout_int;
1884 	const u8 *opmode_notif;
1885 	const struct ieee80211_sec_chan_offs_ie *sec_chan_offs;
1886 	struct ieee80211_mesh_chansw_params_ie *mesh_chansw_params_ie;
1887 	const struct ieee80211_bss_max_idle_period_ie *max_idle_period_ie;
1888 	const struct ieee80211_multiple_bssid_configuration *mbssid_config_ie;
1889 	const struct ieee80211_bssid_index *bssid_index;
1890 	u8 max_bssid_indicator;
1891 	u8 dtim_count;
1892 	u8 dtim_period;
1893 	const struct ieee80211_addba_ext_ie *addba_ext_ie;
1894 	const struct ieee80211_s1g_cap *s1g_capab;
1895 	const struct ieee80211_s1g_oper_ie *s1g_oper;
1896 	const struct ieee80211_s1g_bcn_compat_ie *s1g_bcn_compat;
1897 	const struct ieee80211_aid_response_ie *aid_resp;
1898 	const struct ieee80211_eht_cap_elem *eht_cap;
1899 	const struct ieee80211_eht_operation *eht_operation;
1900 	const struct ieee80211_multi_link_elem *ml_basic;
1901 	const struct ieee80211_multi_link_elem *ml_reconf;
1902 	const struct ieee80211_multi_link_elem *ml_epcs;
1903 	const struct ieee80211_bandwidth_indication *bandwidth_indication;
1904 	const struct ieee80211_ttlm_elem *ttlm[IEEE80211_TTLM_MAX_CNT];
1905 	const struct ieee80211_uhr_cap *uhr_cap;
1906 	const struct ieee80211_uhr_operation *uhr_operation;
1907 	const struct ieee80211_cip_cap *cip_cap;
1908 
1909 	/* not the order in the psd values is per element, not per chandef */
1910 	struct ieee80211_parsed_tpe tpe;
1911 	struct ieee80211_parsed_tpe csa_tpe;
1912 
1913 	/* length of them, respectively */
1914 	u8 ext_capab_len;
1915 	u8 ssid_len;
1916 	u8 supp_rates_len;
1917 	u8 tim_len;
1918 	u8 rsn_len;
1919 	u8 rsnx_len;
1920 	u8 ext_supp_rates_len;
1921 	u8 wmm_info_len;
1922 	u8 wmm_param_len;
1923 	u8 he_cap_len;
1924 	u8 mesh_id_len;
1925 	u8 peering_len;
1926 	u8 preq_len;
1927 	u8 prep_len;
1928 	u8 perr_len;
1929 	u8 country_elem_len;
1930 	u8 bssid_index_len;
1931 	u8 eht_cap_len;
1932 	u8 uhr_cap_len;
1933 	u8 uhr_operation_len;
1934 
1935 	/* mult-link element can be de-fragmented and thus u8 is not sufficient */
1936 	size_t ml_basic_len;
1937 	size_t ml_reconf_len;
1938 	size_t ml_epcs_len;
1939 
1940 	u8 ttlm_num;
1941 
1942 	/*
1943 	 * store the per station profile pointer and length in case that the
1944 	 * parsing also handled Multi-Link element parsing for a specific link
1945 	 * ID.
1946 	 */
1947 	struct ieee80211_mle_per_sta_profile *prof;
1948 	size_t sta_prof_len;
1949 
1950 	/*
1951 	 * When parsing the beacon with MBSSID (from a transmitted BSS), this
1952 	 * indicates that the profile the parser was instructed to look for
1953 	 * (via the bss value in &struct ieee80211_elems_parse_params) couldn't
1954 	 * be found (due to EMA, or perhaps broken AP) and the result cannot be
1955 	 * considered complete.
1956 	 */
1957 	bool mbssid_nontx_profile_missing;
1958 
1959 	/* whether/which parse error occurred while retrieving these elements */
1960 	u8 parse_error;
1961 };
1962 
1963 static inline struct ieee80211_local *hw_to_local(
1964 	struct ieee80211_hw *hw)
1965 {
1966 	return container_of(hw, struct ieee80211_local, hw);
1967 }
1968 
1969 static inline struct txq_info *to_txq_info(struct ieee80211_txq *txq)
1970 {
1971 	return container_of(txq, struct txq_info, txq);
1972 }
1973 
1974 static inline bool txq_has_queue(struct ieee80211_txq *txq)
1975 {
1976 	struct txq_info *txqi = to_txq_info(txq);
1977 
1978 	return !(skb_queue_empty(&txqi->frags) && !txqi->tin.backlog_packets);
1979 }
1980 
1981 static inline bool
1982 ieee80211_have_rx_timestamp(struct ieee80211_rx_status *status)
1983 {
1984 	return status->flag & RX_FLAG_MACTIME;
1985 }
1986 
1987 void ieee80211_vif_inc_num_mcast(struct ieee80211_sub_if_data *sdata);
1988 void ieee80211_vif_dec_num_mcast(struct ieee80211_sub_if_data *sdata);
1989 
1990 void ieee80211_vif_block_queues_csa(struct ieee80211_sub_if_data *sdata);
1991 void ieee80211_vif_unblock_queues_csa(struct ieee80211_sub_if_data *sdata);
1992 
1993 /* This function returns the number of multicast stations connected to this
1994  * interface. It returns -1 if that number is not tracked, that is for netdevs
1995  * not in AP or AP_VLAN mode or when using 4addr.
1996  */
1997 static inline int
1998 ieee80211_vif_get_num_mcast_if(struct ieee80211_sub_if_data *sdata)
1999 {
2000 	if (sdata->vif.type == NL80211_IFTYPE_AP)
2001 		return atomic_read(&sdata->u.ap.num_mcast_sta);
2002 	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
2003 		return atomic_read(&sdata->u.vlan.num_mcast_sta);
2004 	return -1;
2005 }
2006 
2007 static inline bool ieee80211_sdata_running(struct ieee80211_sub_if_data *sdata)
2008 {
2009 	return test_bit(SDATA_STATE_RUNNING, &sdata->state);
2010 }
2011 
2012 int ieee80211_hw_config(struct ieee80211_local *local, int radio_idx,
2013 			u32 changed);
2014 int ieee80211_hw_conf_chan(struct ieee80211_local *local);
2015 void ieee80211_hw_conf_init(struct ieee80211_local *local);
2016 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
2017 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
2018 				      u64 changed);
2019 void ieee80211_vif_cfg_change_notify(struct ieee80211_sub_if_data *sdata,
2020 				     u64 changed);
2021 void ieee80211_link_info_change_notify(struct ieee80211_sub_if_data *sdata,
2022 				       struct ieee80211_link_data *link,
2023 				       u64 changed);
2024 void ieee80211_configure_filter(struct ieee80211_local *local);
2025 u64 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
2026 
2027 void ieee80211_handle_queued_frames(struct ieee80211_local *local);
2028 
2029 int ieee80211_attach_ack_skb(struct ieee80211_local *local, struct sk_buff *skb,
2030 			     u64 *cookie, gfp_t gfp);
2031 
2032 void ieee80211_check_fast_rx(struct sta_info *sta);
2033 void __ieee80211_check_fast_rx_iface(struct ieee80211_sub_if_data *sdata);
2034 void ieee80211_check_fast_rx_iface(struct ieee80211_sub_if_data *sdata);
2035 void ieee80211_clear_fast_rx(struct sta_info *sta);
2036 
2037 bool ieee80211_is_our_addr(struct ieee80211_sub_if_data *sdata,
2038 			   const u8 *addr, int *out_link_id);
2039 
2040 /* AP code */
2041 void ieee80211_ap_rx_queued_frame(struct ieee80211_sub_if_data *sdata,
2042 				  struct sk_buff *skb);
2043 void ieee80211_uhr_disable_dbe_all_stas(struct ieee80211_link_data *link);
2044 
2045 /* STA code */
2046 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
2047 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
2048 		       struct cfg80211_auth_request *req);
2049 int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
2050 			struct cfg80211_assoc_request *req);
2051 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
2052 			 struct cfg80211_deauth_request *req);
2053 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
2054 			   struct cfg80211_disassoc_request *req);
2055 void ieee80211_send_pspoll(struct ieee80211_local *local,
2056 			   struct ieee80211_sub_if_data *sdata);
2057 void ieee80211_recalc_ps(struct ieee80211_local *local);
2058 void ieee80211_recalc_ps_vif(struct ieee80211_sub_if_data *sdata);
2059 void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata);
2060 void ieee80211_sta_rx_queued_frame(struct ieee80211_sub_if_data *sdata,
2061 				   struct sk_buff *skb);
2062 void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata);
2063 void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata);
2064 void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata);
2065 void ieee80211_mgd_conn_tx_status(struct ieee80211_sub_if_data *sdata,
2066 				  __le16 fc, bool acked);
2067 void ieee80211_mgd_quiesce(struct ieee80211_sub_if_data *sdata);
2068 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata);
2069 void ieee80211_sta_handle_tspec_ac_params(struct ieee80211_sub_if_data *sdata);
2070 void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
2071 				   u8 reason, bool tx);
2072 void ieee80211_mgd_setup_link(struct ieee80211_link_data *link);
2073 void ieee80211_mgd_stop_link(struct ieee80211_link_data *link);
2074 void ieee80211_mgd_set_link_qos_params(struct ieee80211_link_data *link);
2075 
2076 /* IBSS code */
2077 void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local);
2078 void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata);
2079 void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
2080 			      const u8 *bssid, const u8 *addr, u32 supp_rates);
2081 int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
2082 			struct cfg80211_ibss_params *params);
2083 int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata);
2084 void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata);
2085 void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
2086 				   struct sk_buff *skb);
2087 int ieee80211_ibss_csa_beacon(struct ieee80211_sub_if_data *sdata,
2088 			      struct cfg80211_csa_settings *csa_settings,
2089 			      u64 *changed);
2090 int ieee80211_ibss_finish_csa(struct ieee80211_sub_if_data *sdata,
2091 			      u64 *changed);
2092 void ieee80211_ibss_stop(struct ieee80211_sub_if_data *sdata);
2093 
2094 /* OCB code */
2095 void ieee80211_ocb_work(struct ieee80211_sub_if_data *sdata);
2096 void ieee80211_ocb_rx_no_sta(struct ieee80211_sub_if_data *sdata,
2097 			     const u8 *bssid, const u8 *addr, u32 supp_rates);
2098 void ieee80211_ocb_setup_sdata(struct ieee80211_sub_if_data *sdata);
2099 int ieee80211_ocb_join(struct ieee80211_sub_if_data *sdata,
2100 		       struct ocb_setup *setup);
2101 int ieee80211_ocb_leave(struct ieee80211_sub_if_data *sdata);
2102 
2103 /* mesh code */
2104 void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata);
2105 void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
2106 				   struct sk_buff *skb);
2107 int ieee80211_mesh_csa_beacon(struct ieee80211_sub_if_data *sdata,
2108 			      struct cfg80211_csa_settings *csa_settings,
2109 			      u64 *changed);
2110 int ieee80211_mesh_finish_csa(struct ieee80211_sub_if_data *sdata,
2111 			      u64 *changed);
2112 
2113 /* NAN code */
2114 int ieee80211_nan_set_local_sched(struct ieee80211_sub_if_data *sdata,
2115 				  struct cfg80211_nan_local_sched *sched);
2116 int ieee80211_nan_set_peer_sched(struct ieee80211_sub_if_data *sdata,
2117 				 struct cfg80211_nan_peer_sched *sched);
2118 int ieee80211_nan_set_non_evac_channels(struct ieee80211_sub_if_data *sdata,
2119 					struct cfg80211_nan_non_evac_channels *channels);
2120 void ieee80211_nan_free_peer_sched(struct ieee80211_nan_peer_sched *sched);
2121 void ieee80211_nan_update_ndi_carrier(struct ieee80211_sub_if_data *ndi_sdata);
2122 struct ieee80211_nan_channel *
2123 ieee80211_nan_find_evac_chan(struct ieee80211_local *local,
2124 			     struct ieee80211_sub_if_data *sdata,
2125 			     struct ieee80211_chanctx *ctx);
2126 void ieee80211_nan_evacuate_channel(struct ieee80211_sub_if_data *sdata,
2127 				    struct ieee80211_nan_channel *nan_channel);
2128 
2129 static inline struct ieee80211_sub_if_data *
2130 ieee80211_find_nan_sdata(struct ieee80211_local *local)
2131 {
2132 	struct ieee80211_sub_if_data *sdata;
2133 
2134 	lockdep_assert_wiphy(local->hw.wiphy);
2135 
2136 	/* Find the NAN interface - there can only be one */
2137 	list_for_each_entry(sdata, &local->interfaces, list) {
2138 		if (ieee80211_sdata_running(sdata) &&
2139 		    sdata->vif.type == NL80211_IFTYPE_NAN)
2140 			return sdata;
2141 	}
2142 
2143 	return NULL;
2144 }
2145 
2146 /* scan/BSS handling */
2147 void ieee80211_scan_work(struct wiphy *wiphy, struct wiphy_work *work);
2148 int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
2149 				const u8 *ssid, u8 ssid_len,
2150 				struct ieee80211_channel **channels,
2151 				unsigned int n_channels);
2152 int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
2153 			   struct cfg80211_scan_request *req);
2154 void ieee80211_scan_cancel(struct ieee80211_local *local);
2155 void ieee80211_run_deferred_scan(struct ieee80211_local *local);
2156 void ieee80211_scan_rx(struct ieee80211_local *local, struct sk_buff *skb);
2157 
2158 void ieee80211_inform_bss(struct wiphy *wiphy, struct cfg80211_bss *bss,
2159 			  const struct cfg80211_bss_ies *ies, void *data);
2160 
2161 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
2162 struct ieee80211_bss *
2163 ieee80211_bss_info_update(struct ieee80211_local *local,
2164 			  struct ieee80211_rx_status *rx_status,
2165 			  struct ieee80211_mgmt *mgmt,
2166 			  size_t len,
2167 			  struct ieee80211_channel *channel);
2168 void ieee80211_rx_bss_put(struct ieee80211_local *local,
2169 			  struct ieee80211_bss *bss);
2170 
2171 /* scheduled scan handling */
2172 int
2173 __ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
2174 				     struct cfg80211_sched_scan_request *req);
2175 int ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata,
2176 				       struct cfg80211_sched_scan_request *req);
2177 int ieee80211_request_sched_scan_stop(struct ieee80211_local *local);
2178 void ieee80211_sched_scan_end(struct ieee80211_local *local);
2179 void ieee80211_sched_scan_stopped_work(struct wiphy *wiphy,
2180 				       struct wiphy_work *work);
2181 
2182 /* off-channel/mgmt-tx */
2183 void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local);
2184 void ieee80211_offchannel_return(struct ieee80211_local *local);
2185 void ieee80211_roc_setup(struct ieee80211_local *local);
2186 void ieee80211_start_next_roc(struct ieee80211_local *local);
2187 void ieee80211_reconfig_roc(struct ieee80211_local *local);
2188 void ieee80211_roc_purge(struct ieee80211_local *local,
2189 			 struct ieee80211_sub_if_data *sdata);
2190 int ieee80211_remain_on_channel(struct wiphy *wiphy, struct wireless_dev *wdev,
2191 				struct ieee80211_channel *chan,
2192 				unsigned int duration, u64 cookie,
2193 				const u8 *rx_addr);
2194 int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
2195 				       struct wireless_dev *wdev, u64 cookie);
2196 int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
2197 		      struct cfg80211_mgmt_tx_params *params, u64 cookie);
2198 int ieee80211_mgmt_tx_unlocked(struct wiphy *wiphy, struct wireless_dev *wdev,
2199 			       struct cfg80211_mgmt_tx_params *params,
2200 			       u64 cookie);
2201 int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
2202 				  struct wireless_dev *wdev, u64 cookie);
2203 
2204 /* channel switch handling */
2205 void ieee80211_csa_finalize_work(struct wiphy *wiphy, struct wiphy_work *work);
2206 int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
2207 			     struct cfg80211_csa_settings *params);
2208 
2209 /* color change handling */
2210 void ieee80211_color_change_finalize_work(struct wiphy *wiphy,
2211 					  struct wiphy_work *work);
2212 void ieee80211_color_collision_detection_work(struct wiphy *wiphy,
2213 					      struct wiphy_work *work);
2214 
2215 /* interface handling */
2216 #define MAC80211_SUPPORTED_FEATURES_TX	(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | \
2217 					 NETIF_F_HW_CSUM | NETIF_F_SG | \
2218 					 NETIF_F_HIGHDMA | NETIF_F_GSO_SOFTWARE | \
2219 					 NETIF_F_HW_TC)
2220 #define MAC80211_SUPPORTED_FEATURES_RX	(NETIF_F_RXCSUM)
2221 #define MAC80211_SUPPORTED_FEATURES	(MAC80211_SUPPORTED_FEATURES_TX | \
2222 					 MAC80211_SUPPORTED_FEATURES_RX)
2223 
2224 int ieee80211_iface_init(void);
2225 void ieee80211_iface_exit(void);
2226 int ieee80211_if_add(struct ieee80211_local *local, const char *name,
2227 		     unsigned char name_assign_type,
2228 		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
2229 		     struct vif_params *params);
2230 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
2231 			     enum nl80211_iftype type);
2232 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
2233 void ieee80211_remove_interfaces(struct ieee80211_local *local);
2234 u32 ieee80211_idle_off(struct ieee80211_local *local);
2235 void ieee80211_recalc_idle(struct ieee80211_local *local);
2236 void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
2237 				    const int offset);
2238 int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up);
2239 void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata);
2240 int ieee80211_add_virtual_monitor(struct ieee80211_local *local,
2241 				  struct ieee80211_sub_if_data *creator_sdata);
2242 void ieee80211_del_virtual_monitor(struct ieee80211_local *local);
2243 
2244 bool __ieee80211_recalc_txpower(struct ieee80211_link_data *link);
2245 void ieee80211_recalc_txpower(struct ieee80211_link_data *link,
2246 			      bool update_bss);
2247 void ieee80211_recalc_offload(struct ieee80211_local *local);
2248 
2249 /* link handling */
2250 void ieee80211_link_setup(struct ieee80211_link_data *link);
2251 void ieee80211_link_init(struct ieee80211_sub_if_data *sdata,
2252 			 int link_id,
2253 			 struct ieee80211_link_data *link,
2254 			 struct ieee80211_bss_conf *link_conf);
2255 void ieee80211_link_stop(struct ieee80211_link_data *link);
2256 int ieee80211_vif_set_links(struct ieee80211_sub_if_data *sdata,
2257 			    u16 new_links, u16 dormant_links);
2258 static inline void ieee80211_vif_clear_links(struct ieee80211_sub_if_data *sdata)
2259 {
2260 	ieee80211_vif_set_links(sdata, 0, 0);
2261 }
2262 
2263 void ieee80211_apvlan_link_setup(struct ieee80211_sub_if_data *sdata);
2264 void ieee80211_apvlan_link_clear(struct ieee80211_sub_if_data *sdata);
2265 
2266 /* tx handling */
2267 void ieee80211_clear_tx_pending(struct ieee80211_local *local);
2268 void ieee80211_tx_pending(struct tasklet_struct *t);
2269 netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
2270 					 struct net_device *dev);
2271 netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
2272 				       struct net_device *dev);
2273 netdev_tx_t ieee80211_subif_start_xmit_8023(struct sk_buff *skb,
2274 					    struct net_device *dev);
2275 void __ieee80211_subif_start_xmit(struct sk_buff *skb,
2276 				  struct net_device *dev,
2277 				  u32 info_flags,
2278 				  u32 ctrl_flags);
2279 struct sk_buff *
2280 ieee80211_build_data_template(struct ieee80211_sub_if_data *sdata,
2281 			      struct sk_buff *skb, u32 info_flags);
2282 void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
2283 			  int retry_count, struct ieee80211_tx_status *status);
2284 
2285 void ieee80211_check_fast_xmit(struct sta_info *sta);
2286 void ieee80211_check_fast_xmit_all(struct ieee80211_local *local);
2287 void ieee80211_check_fast_xmit_iface(struct ieee80211_sub_if_data *sdata);
2288 void ieee80211_clear_fast_xmit(struct sta_info *sta);
2289 int ieee80211_tx_control_port(struct wiphy *wiphy, struct net_device *dev,
2290 			      const u8 *buf, size_t len,
2291 			      const u8 *dest, __be16 proto, bool unencrypted,
2292 			      int link_id, u64 cookie);
2293 int ieee80211_probe_mesh_link(struct wiphy *wiphy, struct net_device *dev,
2294 			      const u8 *buf, size_t len);
2295 void __ieee80211_xmit_fast(struct ieee80211_sub_if_data *sdata,
2296 			   struct sta_info *sta,
2297 			   struct ieee80211_fast_tx *fast_tx,
2298 			   struct sk_buff *skb, bool ampdu,
2299 			   const u8 *da, const u8 *sa);
2300 void ieee80211_aggr_check(struct ieee80211_sub_if_data *sdata,
2301 			  struct sta_info *sta, struct sk_buff *skb);
2302 
2303 /* HT */
2304 void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
2305 				     struct ieee80211_sta_ht_cap *ht_cap);
2306 bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
2307 				       const struct ieee80211_sta_ht_cap *own_cap,
2308 				       const struct ieee80211_ht_cap *ht_cap_ie,
2309 				       struct link_sta_info *link_sta);
2310 void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
2311 			  const u8 *da, u16 tid,
2312 			  u16 initiator, u16 reason_code,
2313 			  bool use_ndp);
2314 int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
2315 			       enum ieee80211_smps_mode smps, const u8 *da,
2316 			       const u8 *bssid, int link_id);
2317 void ieee80211_add_addbaext(struct sk_buff *skb,
2318 			    const u8 req_addba_ext_data,
2319 			    u16 buf_size);
2320 u8 ieee80211_retrieve_addba_ext_data(struct sta_info *sta,
2321 				     const void *elem_data, ssize_t elem_len,
2322 				     u16 *buf_size);
2323 void __ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
2324 				    u16 initiator, u16 reason, bool stop);
2325 void __ieee80211_start_rx_ba_session(struct sta_info *sta,
2326 				     u8 dialog_token, u16 timeout,
2327 				     u16 start_seq_num, u16 ba_policy, u16 tid,
2328 				     u16 buf_size, bool tx, bool auto_seq,
2329 				     bool req_ndp,
2330 				     const u8 addba_ext_data);
2331 void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta,
2332 					 enum ieee80211_agg_stop_reason reason);
2333 void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,
2334 			     struct sta_info *sta,
2335 			     struct ieee80211_mgmt *mgmt, size_t len);
2336 void ieee80211_process_addba_resp(struct ieee80211_local *local,
2337 				  struct sta_info *sta,
2338 				  struct ieee80211_mgmt *mgmt,
2339 				  size_t len);
2340 void ieee80211_process_addba_request(struct ieee80211_local *local,
2341 				     struct sta_info *sta,
2342 				     struct ieee80211_mgmt *mgmt,
2343 				     size_t len);
2344 
2345 static inline struct ieee80211_mgmt *
2346 ieee80211_mgmt_ba(struct sk_buff *skb, const u8 *da,
2347 		  struct ieee80211_sub_if_data *sdata)
2348 {
2349 	struct ieee80211_mgmt *mgmt = skb_put_zero(skb, 24);
2350 
2351 	ether_addr_copy(mgmt->da, da);
2352 	ether_addr_copy(mgmt->sa, sdata->vif.addr);
2353 
2354 	if (sdata->vif.type == NL80211_IFTYPE_AP ||
2355 	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
2356 	    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
2357 		ether_addr_copy(mgmt->bssid, sdata->vif.addr);
2358 	else if (sdata->vif.type == NL80211_IFTYPE_STATION)
2359 		ether_addr_copy(mgmt->bssid, sdata->vif.cfg.ap_addr);
2360 	else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
2361 		ether_addr_copy(mgmt->bssid, sdata->u.ibss.bssid);
2362 
2363 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2364 					  IEEE80211_STYPE_ACTION);
2365 	return mgmt;
2366 }
2367 
2368 int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
2369 				   enum ieee80211_agg_stop_reason reason);
2370 void ieee80211_start_tx_ba_cb(struct sta_info *sta, int tid,
2371 			      struct tid_ampdu_tx *tid_tx);
2372 void ieee80211_stop_tx_ba_cb(struct sta_info *sta, int tid,
2373 			     struct tid_ampdu_tx *tid_tx);
2374 void ieee80211_ba_session_work(struct wiphy *wiphy, struct wiphy_work *work);
2375 void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid);
2376 void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid);
2377 
2378 u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs);
2379 enum nl80211_smps_mode
2380 ieee80211_smps_mode_to_smps_mode(enum ieee80211_smps_mode smps);
2381 
2382 void ieee80211_ht_handle_chanwidth_notif(struct ieee80211_local *local,
2383 					 struct ieee80211_sub_if_data *sdata,
2384 					 struct sta_info *sta,
2385 					 struct link_sta_info *link_sta,
2386 					 u8 chanwidth, enum nl80211_band band);
2387 
2388 /* VHT */
2389 void
2390 ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
2391 				    struct ieee80211_supported_band *sband,
2392 				    const struct ieee80211_sta_vht_cap *own_vht_cap,
2393 				    const struct ieee80211_vht_cap *vht_cap_ie,
2394 				    const struct ieee80211_vht_cap *vht_cap_ie2,
2395 				    struct link_sta_info *link_sta);
2396 void ieee80211_process_mu_groups(struct ieee80211_sub_if_data *sdata,
2397 				 struct ieee80211_link_data *link,
2398 				 struct ieee80211_mgmt *mgmt);
2399 u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
2400 				  struct link_sta_info *sta,
2401 				  u8 opmode, enum nl80211_band band);
2402 void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
2403 				 struct link_sta_info *sta,
2404 				 u8 opmode, enum nl80211_band band);
2405 void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
2406 				      struct ieee80211_sta_vht_cap *vht_cap);
2407 void ieee80211_get_vht_mask_from_cap(__le16 vht_cap,
2408 				     u16 vht_mask[NL80211_VHT_NSS_MAX]);
2409 
2410 /* HE */
2411 void
2412 _ieee80211_he_cap_ie_to_sta_he_cap(struct ieee80211_sub_if_data *sdata,
2413 				   const struct ieee80211_sta_he_cap *own_he_cap,
2414 				   const u8 *he_cap_ie, u8 he_cap_len,
2415 				   const struct ieee80211_he_6ghz_capa *he_6ghz_capa,
2416 				   struct link_sta_info *link_sta);
2417 void
2418 ieee80211_he_cap_ie_to_sta_he_cap(struct ieee80211_sub_if_data *sdata,
2419 				  struct ieee80211_supported_band *sband,
2420 				  const u8 *he_cap_ie, u8 he_cap_len,
2421 				  const struct ieee80211_he_6ghz_capa *he_6ghz_capa,
2422 				  struct link_sta_info *link_sta);
2423 void
2424 ieee80211_he_spr_ie_to_bss_conf(struct ieee80211_vif *vif,
2425 				const struct ieee80211_he_spr *he_spr_ie_elem);
2426 
2427 void
2428 ieee80211_he_op_ie_to_bss_conf(struct ieee80211_vif *vif,
2429 			const struct ieee80211_he_operation *he_op_ie_elem);
2430 
2431 /* S1G */
2432 bool ieee80211_s1g_is_twt_setup(struct sk_buff *skb);
2433 void ieee80211_s1g_rx_twt_action(struct ieee80211_sub_if_data *sdata,
2434 				 struct sk_buff *skb);
2435 void ieee80211_s1g_status_twt_action(struct ieee80211_sub_if_data *sdata,
2436 				     struct sk_buff *skb);
2437 void ieee80211_s1g_cap_to_sta_s1g_cap(struct ieee80211_sub_if_data *sdata,
2438 				      const struct ieee80211_s1g_cap *s1g_cap_ie,
2439 				      struct link_sta_info *link_sta);
2440 bool ieee80211_s1g_use_ndp_ba(const struct ieee80211_sub_if_data *sdata,
2441 			      const struct sta_info *sta);
2442 
2443 /* Spectrum management */
2444 void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
2445 				       struct ieee80211_mgmt *mgmt,
2446 				       size_t len);
2447 /**
2448  * ieee80211_parse_ch_switch_ie - parses channel switch IEs
2449  * @sdata: the sdata of the interface which has received the frame
2450  * @elems: parsed 802.11 elements received with the frame
2451  * @current_band: indicates the current band
2452  * @vht_cap_info: VHT capabilities of the transmitter
2453  * @conn: contains information about own capabilities and restrictions
2454  *	to decide which channel switch announcements can be accepted
2455  * @bssid: the currently connected bssid (for reporting)
2456  * @unprot_action: whether the frame was an unprotected frame or not,
2457  *	used for reporting
2458  * @csa_ie: parsed 802.11 csa elements on count, mode, chandef and mesh ttl.
2459  *	All of them will be filled with if success only.
2460  * Return: 0 on success, <0 on error and >0 if there is nothing to parse.
2461  */
2462 int ieee80211_parse_ch_switch_ie(struct ieee80211_sub_if_data *sdata,
2463 				 struct ieee802_11_elems *elems,
2464 				 enum nl80211_band current_band,
2465 				 u32 vht_cap_info,
2466 				 struct ieee80211_conn_settings *conn,
2467 				 u8 *bssid, bool unprot_action,
2468 				 struct ieee80211_csa_ie *csa_ie);
2469 
2470 /* Suspend/resume and hw reconfiguration */
2471 int ieee80211_reconfig(struct ieee80211_local *local);
2472 void ieee80211_stop_device(struct ieee80211_local *local, bool suspend);
2473 
2474 int __ieee80211_suspend(struct ieee80211_hw *hw,
2475 			struct cfg80211_wowlan *wowlan, bool reset);
2476 
2477 static inline int __ieee80211_resume(struct ieee80211_hw *hw)
2478 {
2479 	struct ieee80211_local *local = hw_to_local(hw);
2480 
2481 	WARN(test_bit(SCAN_HW_SCANNING, &local->scanning) &&
2482 	     !test_bit(SCAN_COMPLETED, &local->scanning),
2483 		"%s: resume with hardware scan still in progress\n",
2484 		wiphy_name(hw->wiphy));
2485 
2486 	return ieee80211_reconfig(hw_to_local(hw));
2487 }
2488 
2489 /* utility functions/constants */
2490 extern const void *const mac80211_wiphy_privid; /* for wiphy privid */
2491 const char *ieee80211_conn_mode_str(enum ieee80211_conn_mode mode);
2492 enum ieee80211_conn_bw_limit
2493 ieee80211_min_bw_limit_from_chandef(struct cfg80211_chan_def *chandef);
2494 int ieee80211_frame_duration(enum nl80211_band band, size_t len,
2495 			     int rate, int erp, int short_preamble);
2496 void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata,
2497 					   struct ieee80211_tx_queue_params *qparam,
2498 					   int ac);
2499 void ieee80211_clear_tpe(struct ieee80211_parsed_tpe *tpe);
2500 void ieee80211_set_wmm_default(struct ieee80211_link_data *link,
2501 			       bool bss_notify, bool enable_qos);
2502 void ieee80211_xmit(struct ieee80211_sub_if_data *sdata,
2503 		    struct sta_info *sta, struct sk_buff *skb);
2504 
2505 void __ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
2506 				 struct sk_buff *skb, struct sta_info *sta,
2507 				 int tid, int link_id,
2508 				 enum nl80211_band band);
2509 
2510 static inline bool ieee80211_require_encrypted_assoc(__le16 fc,
2511 						     struct sta_info *sta)
2512 {
2513 	return sta && sta->sta.epp_peer && ieee80211_is_assoc(fc);
2514 }
2515 
2516 static inline void
2517 ieee80211_tx_skb_tid_band(struct ieee80211_sub_if_data *sdata,
2518 			  struct sk_buff *skb, int tid,
2519 			  enum nl80211_band band)
2520 {
2521 	rcu_read_lock();
2522 	__ieee80211_tx_skb_tid_band(sdata, skb, ERR_PTR(-ENOENT),
2523 				    tid, -1, band);
2524 	rcu_read_unlock();
2525 }
2526 
2527 void ieee80211_tx_skb_tid(struct ieee80211_sub_if_data *sdata,
2528 			  struct sk_buff *skb, struct sta_info *sta,
2529 			  int tid, int link_id);
2530 
2531 static inline void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata,
2532 				    struct sk_buff *skb)
2533 {
2534 	/* Send all internal mgmt frames on VO. Accordingly set TID to 7. */
2535 	ieee80211_tx_skb_tid(sdata, skb, NULL, 7, -1);
2536 }
2537 
2538 /**
2539  * struct ieee80211_elems_parse_params - element parsing parameters
2540  * @mode: connection mode for parsing
2541  * @start: pointer to the elements
2542  * @len: length of the elements
2543  * @type: type of the frame the elements came from
2544  *	(action, probe response, beacon, etc.)
2545  * @filter: bitmap of element IDs to filter out while calculating
2546  *	the element CRC
2547  * @crc: CRC starting value
2548  * @bss: the BSS to parse this as, for multi-BSSID cases this can
2549  *	represent a non-transmitting BSS in which case the data
2550  *	for that non-transmitting BSS is returned
2551  * @link_id: the link ID to parse elements for, if a STA profile
2552  *	is present in the multi-link element, or -1 to ignore;
2553  *	note that the code currently assumes parsing an association
2554  *	(or re-association) response frame if this is given
2555  * @from_ap: frame is received from an AP (currently used only
2556  *	for EHT capabilities parsing)
2557  */
2558 struct ieee80211_elems_parse_params {
2559 	enum ieee80211_conn_mode mode;
2560 	const u8 *start;
2561 	size_t len;
2562 	u8 type;
2563 	u64 filter;
2564 	u32 crc;
2565 	struct cfg80211_bss *bss;
2566 	int link_id;
2567 	bool from_ap;
2568 };
2569 
2570 struct ieee802_11_elems *
2571 ieee802_11_parse_elems_full(struct ieee80211_elems_parse_params *params);
2572 
2573 static inline struct ieee802_11_elems *
2574 ieee802_11_parse_elems(const u8 *start, size_t len, u8 type,
2575 		       struct cfg80211_bss *bss)
2576 {
2577 	struct ieee80211_elems_parse_params params = {
2578 		.mode = IEEE80211_CONN_MODE_HIGHEST,
2579 		.start = start,
2580 		.len = len,
2581 		.type = type,
2582 		.bss = bss,
2583 		.link_id = -1,
2584 	};
2585 
2586 	return ieee802_11_parse_elems_full(&params);
2587 }
2588 
2589 extern const int ieee802_1d_to_ac[8];
2590 
2591 static inline int ieee80211_ac_from_tid(int tid)
2592 {
2593 	return ieee802_1d_to_ac[tid & 7];
2594 }
2595 
2596 void ieee80211_dynamic_ps_enable_work(struct wiphy *wiphy,
2597 				      struct wiphy_work *work);
2598 void ieee80211_dynamic_ps_disable_work(struct wiphy *wiphy,
2599 				       struct wiphy_work *work);
2600 void ieee80211_dynamic_ps_timer(struct timer_list *t);
2601 void ieee80211_send_nullfunc(struct ieee80211_local *local,
2602 			     struct ieee80211_sub_if_data *sdata,
2603 			     bool powersave);
2604 void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
2605 				   struct ieee80211_sub_if_data *sdata);
2606 void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
2607 			     struct ieee80211_hdr *hdr, bool ack, u16 tx_time);
2608 unsigned int
2609 ieee80211_get_vif_queues(struct ieee80211_local *local,
2610 			 struct ieee80211_sub_if_data *sdata);
2611 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
2612 				     unsigned long queues,
2613 				     enum queue_stop_reason reason,
2614 				     bool refcounted);
2615 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
2616 				     unsigned long queues,
2617 				     enum queue_stop_reason reason,
2618 				     bool refcounted);
2619 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
2620 				    enum queue_stop_reason reason,
2621 				    bool refcounted);
2622 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
2623 				    enum queue_stop_reason reason,
2624 				    bool refcounted);
2625 static inline void
2626 ieee80211_stop_vif_queues(struct ieee80211_local *local,
2627 			  struct ieee80211_sub_if_data *sdata,
2628 			  enum queue_stop_reason reason)
2629 {
2630 	ieee80211_stop_queues_by_reason(&local->hw,
2631 					ieee80211_get_vif_queues(local, sdata),
2632 					reason, true);
2633 }
2634 
2635 static inline void
2636 ieee80211_wake_vif_queues(struct ieee80211_local *local,
2637 			  struct ieee80211_sub_if_data *sdata,
2638 			  enum queue_stop_reason reason)
2639 {
2640 	ieee80211_wake_queues_by_reason(&local->hw,
2641 					ieee80211_get_vif_queues(local, sdata),
2642 					reason, true);
2643 }
2644 static inline void
2645 ieee80211_stop_vif_queues_norefcount(struct ieee80211_local *local,
2646 				     struct ieee80211_sub_if_data *sdata,
2647 				     enum queue_stop_reason reason)
2648 {
2649 	ieee80211_stop_queues_by_reason(&local->hw,
2650 					ieee80211_get_vif_queues(local, sdata),
2651 					reason, false);
2652 }
2653 static inline void
2654 ieee80211_wake_vif_queues_norefcount(struct ieee80211_local *local,
2655 				     struct ieee80211_sub_if_data *sdata,
2656 				     enum queue_stop_reason reason)
2657 {
2658 	ieee80211_wake_queues_by_reason(&local->hw,
2659 					ieee80211_get_vif_queues(local, sdata),
2660 					reason, false);
2661 }
2662 void ieee80211_add_pending_skb(struct ieee80211_local *local,
2663 			       struct sk_buff *skb);
2664 void ieee80211_add_pending_skbs(struct ieee80211_local *local,
2665 				struct sk_buff_head *skbs);
2666 void ieee80211_flush_queues(struct ieee80211_local *local,
2667 			    struct ieee80211_sub_if_data *sdata, bool drop);
2668 void __ieee80211_flush_queues(struct ieee80211_local *local,
2669 			      struct ieee80211_sub_if_data *sdata,
2670 			      unsigned int queues, bool drop);
2671 
2672 static inline bool ieee80211_can_run_worker(struct ieee80211_local *local)
2673 {
2674 	/*
2675 	 * It's unsafe to try to do any work during reconfigure flow.
2676 	 * When the flow ends the work will be requeued.
2677 	 */
2678 	if (local->in_reconfig)
2679 		return false;
2680 
2681 	/*
2682 	 * If quiescing is set, we are racing with __ieee80211_suspend.
2683 	 * __ieee80211_suspend flushes the workers after setting quiescing,
2684 	 * and we check quiescing / suspended before enqueuing new workers.
2685 	 * We should abort the worker to avoid the races below.
2686 	 */
2687 	if (local->quiescing)
2688 		return false;
2689 
2690 	/*
2691 	 * We might already be suspended if the following scenario occurs:
2692 	 * __ieee80211_suspend		Control path
2693 	 *
2694 	 *				if (local->quiescing)
2695 	 *					return;
2696 	 * local->quiescing = true;
2697 	 * flush_workqueue();
2698 	 *				queue_work(...);
2699 	 * local->suspended = true;
2700 	 * local->quiescing = false;
2701 	 *				worker starts running...
2702 	 */
2703 	if (local->suspended)
2704 		return false;
2705 
2706 	return true;
2707 }
2708 
2709 int ieee80211_txq_setup_flows(struct ieee80211_local *local);
2710 void ieee80211_txq_set_params(struct ieee80211_local *local, int radio_idx);
2711 void ieee80211_txq_teardown_flows(struct ieee80211_local *local);
2712 void ieee80211_txq_init(struct ieee80211_sub_if_data *sdata,
2713 			struct sta_info *sta,
2714 			struct txq_info *txq, int tid);
2715 void ieee80211_txq_purge(struct ieee80211_local *local,
2716 			 struct txq_info *txqi);
2717 void ieee80211_purge_sta_txqs(struct sta_info *sta);
2718 void ieee80211_txq_remove_vlan(struct ieee80211_local *local,
2719 			       struct ieee80211_sub_if_data *sdata);
2720 void ieee80211_fill_txq_stats(struct cfg80211_txq_stats *txqstats,
2721 			      struct txq_info *txqi);
2722 void ieee80211_wake_txqs(struct tasklet_struct *t);
2723 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
2724 			 u16 transaction, u16 auth_alg, u16 status,
2725 			 const u8 *extra, size_t extra_len, const u8 *bssid,
2726 			 const u8 *da, const u8 *key, u8 key_len, u8 key_idx,
2727 			 u32 tx_flags);
2728 void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
2729 				    const u8 *da, const u8 *bssid,
2730 				    u16 stype, u16 reason,
2731 				    bool send_frame, u8 *frame_buf);
2732 
2733 enum {
2734 	IEEE80211_PROBE_FLAG_DIRECTED		= BIT(0),
2735 	IEEE80211_PROBE_FLAG_MIN_CONTENT	= BIT(1),
2736 	IEEE80211_PROBE_FLAG_RANDOM_SN		= BIT(2),
2737 };
2738 
2739 int ieee80211_build_preq_ies(struct ieee80211_sub_if_data *sdata, u8 *buffer,
2740 			     size_t buffer_len,
2741 			     struct ieee80211_scan_ies *ie_desc,
2742 			     const u8 *ie, size_t ie_len,
2743 			     u8 bands_used, u32 *rate_masks,
2744 			     struct cfg80211_chan_def *chandef,
2745 			     u32 flags);
2746 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
2747 					  const u8 *src, const u8 *dst,
2748 					  u32 ratemask,
2749 					  struct ieee80211_channel *chan,
2750 					  const u8 *ssid, size_t ssid_len,
2751 					  const u8 *ie, size_t ie_len,
2752 					  u32 flags);
2753 u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
2754 			    struct ieee802_11_elems *elems,
2755 			    enum nl80211_band band, u32 *basic_rates);
2756 int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
2757 				 struct ieee80211_link_data *link,
2758 				 enum ieee80211_smps_mode smps_mode);
2759 void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata,
2760 			   struct ieee80211_link_data *link);
2761 void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata,
2762 				  int link_id);
2763 
2764 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset);
2765 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2766 			      u16 cap);
2767 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2768 			       const struct cfg80211_chan_def *chandef,
2769 			       u16 prot_mode, bool rifs_mode);
2770 void ieee80211_ie_build_wide_bw_cs(u8 *pos,
2771 				   const struct cfg80211_chan_def *chandef);
2772 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2773 			       u32 cap);
2774 u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2775 				const struct cfg80211_chan_def *chandef);
2776 u8 ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data *sdata);
2777 u8 *ieee80211_ie_build_he_oper(u8 *pos, const struct cfg80211_chan_def *chandef);
2778 u8 *ieee80211_ie_build_eht_oper(u8 *pos, const struct cfg80211_chan_def *chandef,
2779 				const struct ieee80211_sta_eht_cap *eht_cap);
2780 int ieee80211_parse_bitrates(const struct ieee80211_supported_band *sband,
2781 			     const u8 *srates, int srates_len, u32 *rates);
2782 u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo);
2783 void ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data *sdata,
2784 				struct ieee80211_sta_s1g_cap *caps,
2785 				struct sk_buff *skb);
2786 void ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data *sdata,
2787 				  struct sk_buff *skb);
2788 
2789 enum nl80211_chan_width
2790 ieee80211_sta_rx_bw_to_chan_width(enum ieee80211_sta_rx_bandwidth bw);
2791 
2792 /* element building in SKBs */
2793 int ieee80211_put_srates_elem(struct sk_buff *skb,
2794 			      const struct ieee80211_supported_band *sband,
2795 			      u32 basic_rates, u32 masked_rates,
2796 			      u8 element_id);
2797 int ieee80211_put_he_cap(struct sk_buff *skb,
2798 			 struct ieee80211_sub_if_data *sdata,
2799 			 const struct ieee80211_supported_band *sband,
2800 			 const struct ieee80211_conn_settings *conn);
2801 int ieee80211_put_he_6ghz_cap(struct sk_buff *skb,
2802 			      struct ieee80211_sub_if_data *sdata,
2803 			      enum ieee80211_smps_mode smps_mode);
2804 int ieee80211_put_eht_cap(struct sk_buff *skb,
2805 			  struct ieee80211_sub_if_data *sdata,
2806 			  const struct ieee80211_supported_band *sband,
2807 			  const struct ieee80211_conn_settings *conn);
2808 int ieee80211_put_uhr_cap(struct sk_buff *skb,
2809 			  struct ieee80211_sub_if_data *sdata,
2810 			  const struct ieee80211_supported_band *sband);
2811 void ieee80211_put_reg_conn(struct ieee80211_sub_if_data *sdata,
2812 			    struct sk_buff *skb);
2813 int ieee80211_put_cip_cap(struct sk_buff *skb,
2814 			  struct ieee80211_sub_if_data *sdata);
2815 
2816 /* channel management */
2817 bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
2818 			       struct cfg80211_chan_def *chandef);
2819 bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw, u32 vht_cap_info,
2820 				const struct ieee80211_vht_operation *oper,
2821 				const struct ieee80211_ht_operation *htop,
2822 				struct cfg80211_chan_def *chandef);
2823 void ieee80211_chandef_eht_oper(const struct ieee80211_eht_operation_info *info,
2824 				struct cfg80211_chan_def *chandef);
2825 bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_local *local,
2826 				    const struct ieee80211_he_operation *he_oper,
2827 				    const struct ieee80211_eht_operation *eht_oper,
2828 				    struct cfg80211_chan_def *chandef);
2829 bool ieee80211_chandef_s1g_oper(struct ieee80211_local *local,
2830 				const struct ieee80211_s1g_oper_ie *oper,
2831 				struct cfg80211_chan_def *chandef);
2832 void ieee80211_chandef_downgrade(struct cfg80211_chan_def *chandef,
2833 				 struct ieee80211_conn_settings *conn);
2834 static inline void
2835 ieee80211_chanreq_downgrade(struct ieee80211_chan_req *chanreq,
2836 			    struct ieee80211_conn_settings *conn)
2837 {
2838 	ieee80211_chandef_downgrade(&chanreq->oper, conn);
2839 	if (WARN_ON(!conn))
2840 		return;
2841 	if (conn->mode < IEEE80211_CONN_MODE_EHT)
2842 		chanreq->ap.chan = NULL;
2843 	conn->dbe_enabled = false;
2844 }
2845 
2846 bool ieee80211_chanreq_identical(const struct ieee80211_chan_req *a,
2847 				 const struct ieee80211_chan_req *b);
2848 
2849 int __must_check
2850 _ieee80211_link_use_channel(struct ieee80211_link_data *link,
2851 			    const struct ieee80211_chan_req *req,
2852 			    enum ieee80211_chanctx_mode mode,
2853 			    bool assign_on_failure);
2854 
2855 static inline int __must_check
2856 ieee80211_link_use_channel(struct ieee80211_link_data *link,
2857 			   const struct ieee80211_chan_req *req,
2858 			   enum ieee80211_chanctx_mode mode)
2859 {
2860 	return _ieee80211_link_use_channel(link, req, mode, false);
2861 }
2862 
2863 int __must_check
2864 ieee80211_link_reserve_chanctx(struct ieee80211_link_data *link,
2865 			       const struct ieee80211_chan_req *req,
2866 			       enum ieee80211_chanctx_mode mode,
2867 			       bool radar_required);
2868 int __must_check
2869 ieee80211_link_use_reserved_context(struct ieee80211_link_data *link);
2870 void ieee80211_link_unreserve_chanctx(struct ieee80211_link_data *link);
2871 
2872 int __must_check
2873 ieee80211_link_change_chanreq(struct ieee80211_link_data *link,
2874 			      const struct ieee80211_chan_req *req,
2875 			      u64 *changed);
2876 void __ieee80211_link_release_channel(struct ieee80211_link_data *link,
2877 				      bool skip_idle_recalc);
2878 void ieee80211_link_release_channel(struct ieee80211_link_data *link);
2879 void ieee80211_link_vlan_copy_chanctx(struct ieee80211_link_data *link);
2880 void ieee80211_link_copy_chanctx_to_vlans(struct ieee80211_link_data *link,
2881 					  bool clear);
2882 int ieee80211_chanctx_refcount(struct ieee80211_local *local,
2883 			       struct ieee80211_chanctx *ctx);
2884 
2885 void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
2886 				   struct ieee80211_chanctx *chanctx);
2887 void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
2888 				      struct ieee80211_chanctx *ctx);
2889 bool ieee80211_is_radar_required(struct ieee80211_local *local,
2890 				 struct cfg80211_scan_request *req);
2891 bool ieee80211_is_radio_idx_in_scan_req(struct wiphy *wiphy,
2892 					struct cfg80211_scan_request *scan_req,
2893 					int radio_idx);
2894 
2895 void ieee80211_dfs_cac_timer_work(struct wiphy *wiphy, struct wiphy_work *work);
2896 void ieee80211_dfs_cac_cancel(struct ieee80211_local *local,
2897 			      struct ieee80211_chanctx *chanctx);
2898 void ieee80211_dfs_radar_detected_work(struct wiphy *wiphy,
2899 				       struct wiphy_work *work);
2900 int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
2901 			      struct cfg80211_csa_settings *csa_settings);
2902 void ieee80211_recalc_sb_count(struct ieee80211_sub_if_data *sdata, u64 tsf);
2903 void ieee80211_recalc_dtim(struct ieee80211_sub_if_data *sdata, u64 tsf);
2904 
2905 struct ieee80211_check_combinations_data {
2906 	const struct cfg80211_chan_def *chandef;
2907 	enum ieee80211_chanctx_mode chanmode;
2908 	u8 radar_detect;
2909 	int radio_idx;
2910 	bool (*chanctx_filter)(struct ieee80211_chanctx *ctx,
2911 			       void *filter_data);
2912 	void *filter_data;
2913 };
2914 
2915 int ieee80211_check_combinations_ext(struct ieee80211_sub_if_data *sdata,
2916 				     struct ieee80211_check_combinations_data *data);
2917 
2918 static inline int
2919 ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
2920 			     const struct cfg80211_chan_def *chandef,
2921 			     enum ieee80211_chanctx_mode chanmode,
2922 			     u8 radar_detect, int radio_idx)
2923 {
2924 	struct ieee80211_check_combinations_data data = {
2925 		.chandef = chandef,
2926 		.chanmode = chanmode,
2927 		.radar_detect = radar_detect,
2928 		.radio_idx = radio_idx,
2929 	};
2930 
2931 	return ieee80211_check_combinations_ext(sdata, &data);
2932 }
2933 
2934 int ieee80211_max_num_channels(struct ieee80211_local *local, int radio_idx);
2935 u32 ieee80211_get_radio_mask(struct wiphy *wiphy, struct net_device *dev);
2936 void ieee80211_recalc_chanctx_chantype(struct ieee80211_local *local,
2937 				       struct ieee80211_chanctx *ctx);
2938 struct ieee80211_chanctx *
2939 ieee80211_find_or_create_chanctx(struct ieee80211_sub_if_data *sdata,
2940 				 const struct ieee80211_chan_req *chanreq,
2941 				 enum ieee80211_chanctx_mode mode,
2942 				 bool assign_on_failure,
2943 				 bool *reused_ctx);
2944 void ieee80211_free_chanctx(struct ieee80211_local *local,
2945 			    struct ieee80211_chanctx *ctx,
2946 			    bool skip_idle_recalc);
2947 int ieee80211_chanctx_num_assigned(struct ieee80211_local *local,
2948 				   struct ieee80211_chanctx *ctx);
2949 /* TDLS */
2950 int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
2951 			const u8 *peer, int link_id,
2952 			u8 action_code, u8 dialog_token, u16 status_code,
2953 			u32 peer_capability, bool initiator,
2954 			const u8 *extra_ies, size_t extra_ies_len);
2955 int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
2956 			const u8 *peer, enum nl80211_tdls_operation oper);
2957 void ieee80211_tdls_peer_del_work(struct wiphy *wiphy, struct wiphy_work *wk);
2958 int ieee80211_tdls_channel_switch(struct wiphy *wiphy, struct net_device *dev,
2959 				  const u8 *addr, u8 oper_class,
2960 				  struct cfg80211_chan_def *chandef);
2961 void ieee80211_tdls_cancel_channel_switch(struct wiphy *wiphy,
2962 					  struct net_device *dev,
2963 					  const u8 *addr);
2964 void ieee80211_teardown_tdls_peers(struct ieee80211_link_data *link);
2965 void ieee80211_tdls_handle_disconnect(struct ieee80211_sub_if_data *sdata,
2966 				      const u8 *peer, u16 reason);
2967 void
2968 ieee80211_process_tdls_channel_switch(struct ieee80211_sub_if_data *sdata,
2969 				      struct sk_buff *skb);
2970 
2971 
2972 const char *ieee80211_get_reason_code_string(u16 reason_code);
2973 u16 ieee80211_encode_usf(int val);
2974 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
2975 			enum nl80211_iftype type);
2976 
2977 extern const struct ethtool_ops ieee80211_ethtool_ops;
2978 
2979 u32 ieee80211_rate_expected_tx_airtime(struct ieee80211_hw *hw,
2980 				       struct ieee80211_tx_rate *tx_rate,
2981 				       struct rate_info *ri,
2982 				       enum nl80211_band band,
2983 				       bool ampdu, int len);
2984 u32 ieee80211_calc_expected_tx_airtime(struct ieee80211_hw *hw,
2985 				       struct ieee80211_vif *vif,
2986 				       struct ieee80211_sta *pubsta,
2987 				       int len, bool ampdu);
2988 #ifdef CONFIG_MAC80211_NOINLINE
2989 #define debug_noinline noinline
2990 #else
2991 #define debug_noinline
2992 #endif
2993 
2994 void ieee80211_init_frag_cache(struct ieee80211_fragment_cache *cache);
2995 void ieee80211_destroy_frag_cache(struct ieee80211_fragment_cache *cache);
2996 
2997 u8 ieee80211_ie_len_eht_cap(struct ieee80211_sub_if_data *sdata);
2998 
2999 void
3000 ieee80211_eht_cap_ie_to_sta_eht_cap(struct ieee80211_sub_if_data *sdata,
3001 				    struct ieee80211_supported_band *sband,
3002 				    const u8 *he_cap_ie, u8 he_cap_len,
3003 				    const struct ieee80211_eht_cap_elem *eht_cap_ie_elem,
3004 				    u8 eht_cap_len,
3005 				    struct link_sta_info *link_sta);
3006 int ieee80211_req_neg_ttlm(struct ieee80211_sub_if_data *sdata,
3007 			   struct cfg80211_ttlm_params *params);
3008 
3009 void ieee80211_check_wbrf_support(struct ieee80211_local *local);
3010 void ieee80211_add_wbrf(struct ieee80211_local *local, struct cfg80211_chan_def *chandef);
3011 void ieee80211_remove_wbrf(struct ieee80211_local *local, struct cfg80211_chan_def *chandef);
3012 int ieee80211_mgd_set_epcs(struct ieee80211_sub_if_data *sdata, bool enable);
3013 
3014 int ieee80211_mgd_assoc_ml_reconf(struct ieee80211_sub_if_data *sdata,
3015 				  struct cfg80211_ml_reconf_req *req);
3016 
3017 void ieee80211_stop_mbssid(struct ieee80211_sub_if_data *sdata);
3018 
3019 void
3020 ieee80211_uhr_cap_ie_to_sta_uhr_cap(struct ieee80211_sub_if_data *sdata,
3021 				    struct ieee80211_supported_band *sband,
3022 				    const struct ieee80211_uhr_cap *uhr_cap,
3023 				    u8 uhr_cap_len,
3024 				    struct link_sta_info *link_sta);
3025 
3026 #if IS_ENABLED(CONFIG_MAC80211_KUNIT_TEST)
3027 #define EXPORT_SYMBOL_IF_MAC80211_KUNIT(sym) EXPORT_SYMBOL_IF_KUNIT(sym)
3028 #define VISIBLE_IF_MAC80211_KUNIT
3029 ieee80211_rx_result
3030 ieee80211_drop_unencrypted_mgmt(struct ieee80211_rx_data *rx);
3031 int ieee80211_calc_chandef_subchan_offset(const struct cfg80211_chan_def *ap,
3032 					  u8 n_partial_subchans);
3033 void ieee80211_rearrange_tpe_psd(struct ieee80211_parsed_tpe_psd *psd,
3034 				 const struct cfg80211_chan_def *ap,
3035 				 const struct cfg80211_chan_def *used);
3036 struct ieee802_11_elems *
3037 ieee80211_determine_chan_mode(struct ieee80211_sub_if_data *sdata,
3038 			      struct ieee80211_conn_settings *conn,
3039 			      struct cfg80211_bss *cbss,
3040 			      struct link_sta_info *link_sta, int link_id,
3041 			      struct ieee80211_chan_req *chanreq,
3042 			      struct cfg80211_chan_def *ap_chandef,
3043 			      unsigned long *userspace_selectors);
3044 int ieee80211_parse_neg_ttlm(struct ieee80211_sub_if_data *sdata,
3045 			     const struct ieee80211_ttlm_elem *ttlm,
3046 			     struct ieee80211_neg_ttlm *neg_ttlm,
3047 			     u8 *direction);
3048 #else
3049 #define EXPORT_SYMBOL_IF_MAC80211_KUNIT(sym)
3050 #define VISIBLE_IF_MAC80211_KUNIT static
3051 #endif
3052 
3053 #endif /* IEEE80211_I_H */
3054