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