1 /* SPDX-License-Identifier: GPL-2.0-only */
2 #ifndef __NET_CFG80211_H
3 #define __NET_CFG80211_H
4 /*
5  * 802.11 device and configuration interface
6  *
7  * Copyright 2006-2010	Johannes Berg <johannes@sipsolutions.net>
8  * Copyright 2013-2014 Intel Mobile Communications GmbH
9  * Copyright 2015-2017	Intel Deutschland GmbH
10  * Copyright (C) 2018-2021, 2023 Intel Corporation
11  */
12 
13 #include <linux/ethtool.h>
14 #include <uapi/linux/rfkill.h>
15 #include <linux/netdevice.h>
16 #include <linux/debugfs.h>
17 #include <linux/list.h>
18 #include <linux/bug.h>
19 #include <linux/netlink.h>
20 #include <linux/skbuff.h>
21 #include <linux/nl80211.h>
22 #include <linux/if_ether.h>
23 #include <linux/ieee80211.h>
24 #include <linux/net.h>
25 #include <linux/rfkill.h>
26 #include <net/regulatory.h>
27 
28 /**
29  * DOC: Introduction
30  *
31  * cfg80211 is the configuration API for 802.11 devices in Linux. It bridges
32  * userspace and drivers, and offers some utility functionality associated
33  * with 802.11. cfg80211 must, directly or indirectly via mac80211, be used
34  * by all modern wireless drivers in Linux, so that they offer a consistent
35  * API through nl80211. For backward compatibility, cfg80211 also offers
36  * wireless extensions to userspace, but hides them from drivers completely.
37  *
38  * Additionally, cfg80211 contains code to help enforce regulatory spectrum
39  * use restrictions.
40  */
41 
42 
43 /**
44  * DOC: Device registration
45  *
46  * In order for a driver to use cfg80211, it must register the hardware device
47  * with cfg80211. This happens through a number of hardware capability structs
48  * described below.
49  *
50  * The fundamental structure for each device is the 'wiphy', of which each
51  * instance describes a physical wireless device connected to the system. Each
52  * such wiphy can have zero, one, or many virtual interfaces associated with
53  * it, which need to be identified as such by pointing the network interface's
54  * @ieee80211_ptr pointer to a &struct wireless_dev which further describes
55  * the wireless part of the interface, normally this struct is embedded in the
56  * network interface's private data area. Drivers can optionally allow creating
57  * or destroying virtual interfaces on the fly, but without at least one or the
58  * ability to create some the wireless device isn't useful.
59  *
60  * Each wiphy structure contains device capability information, and also has
61  * a pointer to the various operations the driver offers. The definitions and
62  * structures here describe these capabilities in detail.
63  */
64 
65 struct wiphy;
66 
67 /*
68  * wireless hardware capability structures
69  */
70 
71 /**
72  * enum ieee80211_channel_flags - channel flags
73  *
74  * Channel flags set by the regulatory control code.
75  *
76  * @IEEE80211_CHAN_DISABLED: This channel is disabled.
77  * @IEEE80211_CHAN_NO_IR: do not initiate radiation, this includes
78  *	sending probe requests or beaconing.
79  * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel.
80  * @IEEE80211_CHAN_NO_HT40PLUS: extension channel above this channel
81  *	is not permitted.
82  * @IEEE80211_CHAN_NO_HT40MINUS: extension channel below this channel
83  *	is not permitted.
84  * @IEEE80211_CHAN_NO_OFDM: OFDM is not allowed on this channel.
85  * @IEEE80211_CHAN_NO_80MHZ: If the driver supports 80 MHz on the band,
86  *	this flag indicates that an 80 MHz channel cannot use this
87  *	channel as the control or any of the secondary channels.
88  *	This may be due to the driver or due to regulatory bandwidth
89  *	restrictions.
90  * @IEEE80211_CHAN_NO_160MHZ: If the driver supports 160 MHz on the band,
91  *	this flag indicates that an 160 MHz channel cannot use this
92  *	channel as the control or any of the secondary channels.
93  *	This may be due to the driver or due to regulatory bandwidth
94  *	restrictions.
95  * @IEEE80211_CHAN_INDOOR_ONLY: see %NL80211_FREQUENCY_ATTR_INDOOR_ONLY
96  * @IEEE80211_CHAN_IR_CONCURRENT: see %NL80211_FREQUENCY_ATTR_IR_CONCURRENT
97  * @IEEE80211_CHAN_NO_20MHZ: 20 MHz bandwidth is not permitted
98  *	on this channel.
99  * @IEEE80211_CHAN_NO_10MHZ: 10 MHz bandwidth is not permitted
100  *	on this channel.
101  * @IEEE80211_CHAN_NO_HE: HE operation is not permitted on this channel.
102  * @IEEE80211_CHAN_1MHZ: 1 MHz bandwidth is permitted
103  *	on this channel.
104  * @IEEE80211_CHAN_2MHZ: 2 MHz bandwidth is permitted
105  *	on this channel.
106  * @IEEE80211_CHAN_4MHZ: 4 MHz bandwidth is permitted
107  *	on this channel.
108  * @IEEE80211_CHAN_8MHZ: 8 MHz bandwidth is permitted
109  *	on this channel.
110  * @IEEE80211_CHAN_16MHZ: 16 MHz bandwidth is permitted
111  *	on this channel.
112  * @IEEE80211_CHAN_NO_320MHZ: If the driver supports 320 MHz on the band,
113  *	this flag indicates that a 320 MHz channel cannot use this
114  *	channel as the control or any of the secondary channels.
115  *	This may be due to the driver or due to regulatory bandwidth
116  *	restrictions.
117  * @IEEE80211_CHAN_NO_EHT: EHT operation is not permitted on this channel.
118  */
119 enum ieee80211_channel_flags {
120 	IEEE80211_CHAN_DISABLED		= 1<<0,
121 	IEEE80211_CHAN_NO_IR		= 1<<1,
122 	/* hole at 1<<2 */
123 	IEEE80211_CHAN_RADAR		= 1<<3,
124 	IEEE80211_CHAN_NO_HT40PLUS	= 1<<4,
125 	IEEE80211_CHAN_NO_HT40MINUS	= 1<<5,
126 	IEEE80211_CHAN_NO_OFDM		= 1<<6,
127 	IEEE80211_CHAN_NO_80MHZ		= 1<<7,
128 	IEEE80211_CHAN_NO_160MHZ	= 1<<8,
129 	IEEE80211_CHAN_INDOOR_ONLY	= 1<<9,
130 	IEEE80211_CHAN_IR_CONCURRENT	= 1<<10,
131 	IEEE80211_CHAN_NO_20MHZ		= 1<<11,
132 	IEEE80211_CHAN_NO_10MHZ		= 1<<12,
133 	IEEE80211_CHAN_NO_HE		= 1<<13,
134 	IEEE80211_CHAN_1MHZ		= 1<<14,
135 	IEEE80211_CHAN_2MHZ		= 1<<15,
136 	IEEE80211_CHAN_4MHZ		= 1<<16,
137 	IEEE80211_CHAN_8MHZ		= 1<<17,
138 	IEEE80211_CHAN_16MHZ		= 1<<18,
139 	IEEE80211_CHAN_NO_320MHZ	= 1<<19,
140 	IEEE80211_CHAN_NO_EHT		= 1<<20,
141 };
142 
143 #define IEEE80211_CHAN_NO_HT40 \
144 	(IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS)
145 
146 #define IEEE80211_DFS_MIN_CAC_TIME_MS		60000
147 #define IEEE80211_DFS_MIN_NOP_TIME_MS		(30 * 60 * 1000)
148 
149 /**
150  * struct ieee80211_channel - channel definition
151  *
152  * This structure describes a single channel for use
153  * with cfg80211.
154  *
155  * @center_freq: center frequency in MHz
156  * @freq_offset: offset from @center_freq, in KHz
157  * @hw_value: hardware-specific value for the channel
158  * @flags: channel flags from &enum ieee80211_channel_flags.
159  * @orig_flags: channel flags at registration time, used by regulatory
160  *	code to support devices with additional restrictions
161  * @band: band this channel belongs to.
162  * @max_antenna_gain: maximum antenna gain in dBi
163  * @max_power: maximum transmission power (in dBm)
164  * @max_reg_power: maximum regulatory transmission power (in dBm)
165  * @beacon_found: helper to regulatory code to indicate when a beacon
166  *	has been found on this channel. Use regulatory_hint_found_beacon()
167  *	to enable this, this is useful only on 5 GHz band.
168  * @orig_mag: internal use
169  * @orig_mpwr: internal use
170  * @dfs_state: current state of this channel. Only relevant if radar is required
171  *	on this channel.
172  * @dfs_state_entered: timestamp (jiffies) when the dfs state was entered.
173  * @dfs_cac_ms: DFS CAC time in milliseconds, this is valid for DFS channels.
174  */
175 struct ieee80211_channel {
176 	enum nl80211_band band;
177 	u32 center_freq;
178 	u16 freq_offset;
179 	u16 hw_value;
180 	u32 flags;
181 	int max_antenna_gain;
182 	int max_power;
183 	int max_reg_power;
184 	bool beacon_found;
185 	u32 orig_flags;
186 	int orig_mag, orig_mpwr;
187 	enum nl80211_dfs_state dfs_state;
188 	unsigned long dfs_state_entered;
189 	unsigned int dfs_cac_ms;
190 };
191 
192 /**
193  * enum ieee80211_rate_flags - rate flags
194  *
195  * Hardware/specification flags for rates. These are structured
196  * in a way that allows using the same bitrate structure for
197  * different bands/PHY modes.
198  *
199  * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short
200  *	preamble on this bitrate; only relevant in 2.4GHz band and
201  *	with CCK rates.
202  * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate
203  *	when used with 802.11a (on the 5 GHz band); filled by the
204  *	core code when registering the wiphy.
205  * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate
206  *	when used with 802.11b (on the 2.4 GHz band); filled by the
207  *	core code when registering the wiphy.
208  * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate
209  *	when used with 802.11g (on the 2.4 GHz band); filled by the
210  *	core code when registering the wiphy.
211  * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode.
212  * @IEEE80211_RATE_SUPPORTS_5MHZ: Rate can be used in 5 MHz mode
213  * @IEEE80211_RATE_SUPPORTS_10MHZ: Rate can be used in 10 MHz mode
214  */
215 enum ieee80211_rate_flags {
216 	IEEE80211_RATE_SHORT_PREAMBLE	= 1<<0,
217 	IEEE80211_RATE_MANDATORY_A	= 1<<1,
218 	IEEE80211_RATE_MANDATORY_B	= 1<<2,
219 	IEEE80211_RATE_MANDATORY_G	= 1<<3,
220 	IEEE80211_RATE_ERP_G		= 1<<4,
221 	IEEE80211_RATE_SUPPORTS_5MHZ	= 1<<5,
222 	IEEE80211_RATE_SUPPORTS_10MHZ	= 1<<6,
223 };
224 
225 /**
226  * enum ieee80211_bss_type - BSS type filter
227  *
228  * @IEEE80211_BSS_TYPE_ESS: Infrastructure BSS
229  * @IEEE80211_BSS_TYPE_PBSS: Personal BSS
230  * @IEEE80211_BSS_TYPE_IBSS: Independent BSS
231  * @IEEE80211_BSS_TYPE_MBSS: Mesh BSS
232  * @IEEE80211_BSS_TYPE_ANY: Wildcard value for matching any BSS type
233  */
234 enum ieee80211_bss_type {
235 	IEEE80211_BSS_TYPE_ESS,
236 	IEEE80211_BSS_TYPE_PBSS,
237 	IEEE80211_BSS_TYPE_IBSS,
238 	IEEE80211_BSS_TYPE_MBSS,
239 	IEEE80211_BSS_TYPE_ANY
240 };
241 
242 /**
243  * enum ieee80211_privacy - BSS privacy filter
244  *
245  * @IEEE80211_PRIVACY_ON: privacy bit set
246  * @IEEE80211_PRIVACY_OFF: privacy bit clear
247  * @IEEE80211_PRIVACY_ANY: Wildcard value for matching any privacy setting
248  */
249 enum ieee80211_privacy {
250 	IEEE80211_PRIVACY_ON,
251 	IEEE80211_PRIVACY_OFF,
252 	IEEE80211_PRIVACY_ANY
253 };
254 
255 #define IEEE80211_PRIVACY(x)	\
256 	((x) ? IEEE80211_PRIVACY_ON : IEEE80211_PRIVACY_OFF)
257 
258 /**
259  * struct ieee80211_rate - bitrate definition
260  *
261  * This structure describes a bitrate that an 802.11 PHY can
262  * operate with. The two values @hw_value and @hw_value_short
263  * are only for driver use when pointers to this structure are
264  * passed around.
265  *
266  * @flags: rate-specific flags from &enum ieee80211_rate_flags
267  * @bitrate: bitrate in units of 100 Kbps
268  * @hw_value: driver/hardware value for this rate
269  * @hw_value_short: driver/hardware value for this rate when
270  *	short preamble is used
271  */
272 struct ieee80211_rate {
273 	u32 flags;
274 	u16 bitrate;
275 	u16 hw_value, hw_value_short;
276 };
277 
278 /**
279  * struct ieee80211_he_obss_pd - AP settings for spatial reuse
280  *
281  * @enable: is the feature enabled.
282  * @sr_ctrl: The SR Control field of SRP element.
283  * @non_srg_max_offset: non-SRG maximum tx power offset
284  * @min_offset: minimal tx power offset an associated station shall use
285  * @max_offset: maximum tx power offset an associated station shall use
286  * @bss_color_bitmap: bitmap that indicates the BSS color values used by
287  *	members of the SRG
288  * @partial_bssid_bitmap: bitmap that indicates the partial BSSID values
289  *	used by members of the SRG
290  */
291 struct ieee80211_he_obss_pd {
292 	bool enable;
293 	u8 sr_ctrl;
294 	u8 non_srg_max_offset;
295 	u8 min_offset;
296 	u8 max_offset;
297 	u8 bss_color_bitmap[8];
298 	u8 partial_bssid_bitmap[8];
299 };
300 
301 /**
302  * struct cfg80211_he_bss_color - AP settings for BSS coloring
303  *
304  * @color: the current color.
305  * @enabled: HE BSS color is used
306  * @partial: define the AID equation.
307  */
308 struct cfg80211_he_bss_color {
309 	u8 color;
310 	bool enabled;
311 	bool partial;
312 };
313 
314 /**
315  * struct ieee80211_sta_ht_cap - STA's HT capabilities
316  *
317  * This structure describes most essential parameters needed
318  * to describe 802.11n HT capabilities for an STA.
319  *
320  * @ht_supported: is HT supported by the STA
321  * @cap: HT capabilities map as described in 802.11n spec
322  * @ampdu_factor: Maximum A-MPDU length factor
323  * @ampdu_density: Minimum A-MPDU spacing
324  * @mcs: Supported MCS rates
325  */
326 struct ieee80211_sta_ht_cap {
327 	u16 cap; /* use IEEE80211_HT_CAP_ */
328 	bool ht_supported;
329 	u8 ampdu_factor;
330 	u8 ampdu_density;
331 	struct ieee80211_mcs_info mcs;
332 };
333 
334 /**
335  * struct ieee80211_sta_vht_cap - STA's VHT capabilities
336  *
337  * This structure describes most essential parameters needed
338  * to describe 802.11ac VHT capabilities for an STA.
339  *
340  * @vht_supported: is VHT supported by the STA
341  * @cap: VHT capabilities map as described in 802.11ac spec
342  * @vht_mcs: Supported VHT MCS rates
343  */
344 struct ieee80211_sta_vht_cap {
345 	bool vht_supported;
346 	u32 cap; /* use IEEE80211_VHT_CAP_ */
347 	struct ieee80211_vht_mcs_info vht_mcs;
348 };
349 
350 #define IEEE80211_HE_PPE_THRES_MAX_LEN		25
351 
352 /**
353  * struct ieee80211_sta_he_cap - STA's HE capabilities
354  *
355  * This structure describes most essential parameters needed
356  * to describe 802.11ax HE capabilities for a STA.
357  *
358  * @has_he: true iff HE data is valid.
359  * @he_cap_elem: Fixed portion of the HE capabilities element.
360  * @he_mcs_nss_supp: The supported NSS/MCS combinations.
361  * @ppe_thres: Holds the PPE Thresholds data.
362  */
363 struct ieee80211_sta_he_cap {
364 	bool has_he;
365 	struct ieee80211_he_cap_elem he_cap_elem;
366 	struct ieee80211_he_mcs_nss_supp he_mcs_nss_supp;
367 	u8 ppe_thres[IEEE80211_HE_PPE_THRES_MAX_LEN];
368 };
369 
370 /**
371  * struct ieee80211_eht_mcs_nss_supp - EHT max supported NSS per MCS
372  *
373  * See P802.11be_D1.3 Table 9-401k - "Subfields of the Supported EHT-MCS
374  * and NSS Set field"
375  *
376  * @only_20mhz: MCS/NSS support for 20 MHz-only STA.
377  * @bw: MCS/NSS support for 80, 160 and 320 MHz
378  * @bw._80: MCS/NSS support for BW <= 80 MHz
379  * @bw._160: MCS/NSS support for BW = 160 MHz
380  * @bw._320: MCS/NSS support for BW = 320 MHz
381  */
382 struct ieee80211_eht_mcs_nss_supp {
383 	union {
384 		struct ieee80211_eht_mcs_nss_supp_20mhz_only only_20mhz;
385 		struct {
386 			struct ieee80211_eht_mcs_nss_supp_bw _80;
387 			struct ieee80211_eht_mcs_nss_supp_bw _160;
388 			struct ieee80211_eht_mcs_nss_supp_bw _320;
389 		} __packed bw;
390 	} __packed;
391 } __packed;
392 
393 #define IEEE80211_EHT_PPE_THRES_MAX_LEN		32
394 
395 /**
396  * struct ieee80211_sta_eht_cap - STA's EHT capabilities
397  *
398  * This structure describes most essential parameters needed
399  * to describe 802.11be EHT capabilities for a STA.
400  *
401  * @has_eht: true iff EHT data is valid.
402  * @eht_cap_elem: Fixed portion of the eht capabilities element.
403  * @eht_mcs_nss_supp: The supported NSS/MCS combinations.
404  * @eht_ppe_thres: Holds the PPE Thresholds data.
405  */
406 struct ieee80211_sta_eht_cap {
407 	bool has_eht;
408 	struct ieee80211_eht_cap_elem_fixed eht_cap_elem;
409 	struct ieee80211_eht_mcs_nss_supp eht_mcs_nss_supp;
410 	u8 eht_ppe_thres[IEEE80211_EHT_PPE_THRES_MAX_LEN];
411 };
412 
413 /**
414  * struct ieee80211_sband_iftype_data - sband data per interface type
415  *
416  * This structure encapsulates sband data that is relevant for the
417  * interface types defined in @types_mask.  Each type in the
418  * @types_mask must be unique across all instances of iftype_data.
419  *
420  * @types_mask: interface types mask
421  * @he_cap: holds the HE capabilities
422  * @he_6ghz_capa: HE 6 GHz capabilities, must be filled in for a
423  *	6 GHz band channel (and 0 may be valid value).
424  * @eht_cap: STA's EHT capabilities
425  * @vendor_elems: vendor element(s) to advertise
426  * @vendor_elems.data: vendor element(s) data
427  * @vendor_elems.len: vendor element(s) length
428  */
429 struct ieee80211_sband_iftype_data {
430 	u16 types_mask;
431 	struct ieee80211_sta_he_cap he_cap;
432 	struct ieee80211_he_6ghz_capa he_6ghz_capa;
433 	struct ieee80211_sta_eht_cap eht_cap;
434 	struct {
435 		const u8 *data;
436 		unsigned int len;
437 	} vendor_elems;
438 };
439 
440 /**
441  * enum ieee80211_edmg_bw_config - allowed channel bandwidth configurations
442  *
443  * @IEEE80211_EDMG_BW_CONFIG_4: 2.16GHz
444  * @IEEE80211_EDMG_BW_CONFIG_5: 2.16GHz and 4.32GHz
445  * @IEEE80211_EDMG_BW_CONFIG_6: 2.16GHz, 4.32GHz and 6.48GHz
446  * @IEEE80211_EDMG_BW_CONFIG_7: 2.16GHz, 4.32GHz, 6.48GHz and 8.64GHz
447  * @IEEE80211_EDMG_BW_CONFIG_8: 2.16GHz and 2.16GHz + 2.16GHz
448  * @IEEE80211_EDMG_BW_CONFIG_9: 2.16GHz, 4.32GHz and 2.16GHz + 2.16GHz
449  * @IEEE80211_EDMG_BW_CONFIG_10: 2.16GHz, 4.32GHz, 6.48GHz and 2.16GHz+2.16GHz
450  * @IEEE80211_EDMG_BW_CONFIG_11: 2.16GHz, 4.32GHz, 6.48GHz, 8.64GHz and
451  *	2.16GHz+2.16GHz
452  * @IEEE80211_EDMG_BW_CONFIG_12: 2.16GHz, 2.16GHz + 2.16GHz and
453  *	4.32GHz + 4.32GHz
454  * @IEEE80211_EDMG_BW_CONFIG_13: 2.16GHz, 4.32GHz, 2.16GHz + 2.16GHz and
455  *	4.32GHz + 4.32GHz
456  * @IEEE80211_EDMG_BW_CONFIG_14: 2.16GHz, 4.32GHz, 6.48GHz, 2.16GHz + 2.16GHz
457  *	and 4.32GHz + 4.32GHz
458  * @IEEE80211_EDMG_BW_CONFIG_15: 2.16GHz, 4.32GHz, 6.48GHz, 8.64GHz,
459  *	2.16GHz + 2.16GHz and 4.32GHz + 4.32GHz
460  */
461 enum ieee80211_edmg_bw_config {
462 	IEEE80211_EDMG_BW_CONFIG_4	= 4,
463 	IEEE80211_EDMG_BW_CONFIG_5	= 5,
464 	IEEE80211_EDMG_BW_CONFIG_6	= 6,
465 	IEEE80211_EDMG_BW_CONFIG_7	= 7,
466 	IEEE80211_EDMG_BW_CONFIG_8	= 8,
467 	IEEE80211_EDMG_BW_CONFIG_9	= 9,
468 	IEEE80211_EDMG_BW_CONFIG_10	= 10,
469 	IEEE80211_EDMG_BW_CONFIG_11	= 11,
470 	IEEE80211_EDMG_BW_CONFIG_12	= 12,
471 	IEEE80211_EDMG_BW_CONFIG_13	= 13,
472 	IEEE80211_EDMG_BW_CONFIG_14	= 14,
473 	IEEE80211_EDMG_BW_CONFIG_15	= 15,
474 };
475 
476 /**
477  * struct ieee80211_edmg - EDMG configuration
478  *
479  * This structure describes most essential parameters needed
480  * to describe 802.11ay EDMG configuration
481  *
482  * @channels: bitmap that indicates the 2.16 GHz channel(s)
483  *	that are allowed to be used for transmissions.
484  *	Bit 0 indicates channel 1, bit 1 indicates channel 2, etc.
485  *	Set to 0 indicate EDMG not supported.
486  * @bw_config: Channel BW Configuration subfield encodes
487  *	the allowed channel bandwidth configurations
488  */
489 struct ieee80211_edmg {
490 	u8 channels;
491 	enum ieee80211_edmg_bw_config bw_config;
492 };
493 
494 /**
495  * struct ieee80211_sta_s1g_cap - STA's S1G capabilities
496  *
497  * This structure describes most essential parameters needed
498  * to describe 802.11ah S1G capabilities for a STA.
499  *
500  * @s1g: is STA an S1G STA
501  * @cap: S1G capabilities information
502  * @nss_mcs: Supported NSS MCS set
503  */
504 struct ieee80211_sta_s1g_cap {
505 	bool s1g;
506 	u8 cap[10]; /* use S1G_CAPAB_ */
507 	u8 nss_mcs[5];
508 };
509 
510 /**
511  * struct ieee80211_supported_band - frequency band definition
512  *
513  * This structure describes a frequency band a wiphy
514  * is able to operate in.
515  *
516  * @channels: Array of channels the hardware can operate with
517  *	in this band.
518  * @band: the band this structure represents
519  * @n_channels: Number of channels in @channels
520  * @bitrates: Array of bitrates the hardware can operate with
521  *	in this band. Must be sorted to give a valid "supported
522  *	rates" IE, i.e. CCK rates first, then OFDM.
523  * @n_bitrates: Number of bitrates in @bitrates
524  * @ht_cap: HT capabilities in this band
525  * @vht_cap: VHT capabilities in this band
526  * @s1g_cap: S1G capabilities in this band
527  * @edmg_cap: EDMG capabilities in this band
528  * @s1g_cap: S1G capabilities in this band (S1B band only, of course)
529  * @n_iftype_data: number of iftype data entries
530  * @iftype_data: interface type data entries.  Note that the bits in
531  *	@types_mask inside this structure cannot overlap (i.e. only
532  *	one occurrence of each type is allowed across all instances of
533  *	iftype_data).
534  */
535 struct ieee80211_supported_band {
536 	struct ieee80211_channel *channels;
537 	struct ieee80211_rate *bitrates;
538 	enum nl80211_band band;
539 	int n_channels;
540 	int n_bitrates;
541 	struct ieee80211_sta_ht_cap ht_cap;
542 	struct ieee80211_sta_vht_cap vht_cap;
543 	struct ieee80211_sta_s1g_cap s1g_cap;
544 	struct ieee80211_edmg edmg_cap;
545 	u16 n_iftype_data;
546 	const struct ieee80211_sband_iftype_data *iftype_data;
547 };
548 
549 /**
550  * ieee80211_get_sband_iftype_data - return sband data for a given iftype
551  * @sband: the sband to search for the STA on
552  * @iftype: enum nl80211_iftype
553  *
554  * Return: pointer to struct ieee80211_sband_iftype_data, or NULL is none found
555  */
556 static inline const struct ieee80211_sband_iftype_data *
ieee80211_get_sband_iftype_data(const struct ieee80211_supported_band * sband,u8 iftype)557 ieee80211_get_sband_iftype_data(const struct ieee80211_supported_band *sband,
558 				u8 iftype)
559 {
560 	int i;
561 
562 	if (WARN_ON(iftype >= NL80211_IFTYPE_MAX))
563 		return NULL;
564 
565 	if (iftype == NL80211_IFTYPE_AP_VLAN)
566 		iftype = NL80211_IFTYPE_AP;
567 
568 	for (i = 0; i < sband->n_iftype_data; i++)  {
569 		const struct ieee80211_sband_iftype_data *data =
570 			&sband->iftype_data[i];
571 
572 		if (data->types_mask & BIT(iftype))
573 			return data;
574 	}
575 
576 	return NULL;
577 }
578 
579 /**
580  * ieee80211_get_he_iftype_cap - return HE capabilities for an sband's iftype
581  * @sband: the sband to search for the iftype on
582  * @iftype: enum nl80211_iftype
583  *
584  * Return: pointer to the struct ieee80211_sta_he_cap, or NULL is none found
585  */
586 static inline const struct ieee80211_sta_he_cap *
ieee80211_get_he_iftype_cap(const struct ieee80211_supported_band * sband,u8 iftype)587 ieee80211_get_he_iftype_cap(const struct ieee80211_supported_band *sband,
588 			    u8 iftype)
589 {
590 	const struct ieee80211_sband_iftype_data *data =
591 		ieee80211_get_sband_iftype_data(sband, iftype);
592 
593 	if (data && data->he_cap.has_he)
594 		return &data->he_cap;
595 
596 	return NULL;
597 }
598 
599 /**
600  * ieee80211_get_he_6ghz_capa - return HE 6 GHz capabilities
601  * @sband: the sband to search for the STA on
602  * @iftype: the iftype to search for
603  *
604  * Return: the 6GHz capabilities
605  */
606 static inline __le16
ieee80211_get_he_6ghz_capa(const struct ieee80211_supported_band * sband,enum nl80211_iftype iftype)607 ieee80211_get_he_6ghz_capa(const struct ieee80211_supported_band *sband,
608 			   enum nl80211_iftype iftype)
609 {
610 	const struct ieee80211_sband_iftype_data *data =
611 		ieee80211_get_sband_iftype_data(sband, iftype);
612 
613 	if (WARN_ON(!data || !data->he_cap.has_he))
614 		return 0;
615 
616 	return data->he_6ghz_capa.capa;
617 }
618 
619 /**
620  * ieee80211_get_eht_iftype_cap - return ETH capabilities for an sband's iftype
621  * @sband: the sband to search for the iftype on
622  * @iftype: enum nl80211_iftype
623  *
624  * Return: pointer to the struct ieee80211_sta_eht_cap, or NULL is none found
625  */
626 static inline const struct ieee80211_sta_eht_cap *
ieee80211_get_eht_iftype_cap(const struct ieee80211_supported_band * sband,enum nl80211_iftype iftype)627 ieee80211_get_eht_iftype_cap(const struct ieee80211_supported_band *sband,
628 			     enum nl80211_iftype iftype)
629 {
630 	const struct ieee80211_sband_iftype_data *data =
631 		ieee80211_get_sband_iftype_data(sband, iftype);
632 
633 	if (data && data->eht_cap.has_eht)
634 		return &data->eht_cap;
635 
636 	return NULL;
637 }
638 
639 /**
640  * wiphy_read_of_freq_limits - read frequency limits from device tree
641  *
642  * @wiphy: the wireless device to get extra limits for
643  *
644  * Some devices may have extra limitations specified in DT. This may be useful
645  * for chipsets that normally support more bands but are limited due to board
646  * design (e.g. by antennas or external power amplifier).
647  *
648  * This function reads info from DT and uses it to *modify* channels (disable
649  * unavailable ones). It's usually a *bad* idea to use it in drivers with
650  * shared channel data as DT limitations are device specific. You should make
651  * sure to call it only if channels in wiphy are copied and can be modified
652  * without affecting other devices.
653  *
654  * As this function access device node it has to be called after set_wiphy_dev.
655  * It also modifies channels so they have to be set first.
656  * If using this helper, call it before wiphy_register().
657  */
658 #ifdef CONFIG_OF
659 void wiphy_read_of_freq_limits(struct wiphy *wiphy);
660 #else /* CONFIG_OF */
wiphy_read_of_freq_limits(struct wiphy * wiphy)661 static inline void wiphy_read_of_freq_limits(struct wiphy *wiphy)
662 {
663 }
664 #endif /* !CONFIG_OF */
665 
666 
667 /*
668  * Wireless hardware/device configuration structures and methods
669  */
670 
671 /**
672  * DOC: Actions and configuration
673  *
674  * Each wireless device and each virtual interface offer a set of configuration
675  * operations and other actions that are invoked by userspace. Each of these
676  * actions is described in the operations structure, and the parameters these
677  * operations use are described separately.
678  *
679  * Additionally, some operations are asynchronous and expect to get status
680  * information via some functions that drivers need to call.
681  *
682  * Scanning and BSS list handling with its associated functionality is described
683  * in a separate chapter.
684  */
685 
686 #define VHT_MUMIMO_GROUPS_DATA_LEN (WLAN_MEMBERSHIP_LEN +\
687 				    WLAN_USER_POSITION_LEN)
688 
689 /**
690  * struct vif_params - describes virtual interface parameters
691  * @flags: monitor interface flags, unchanged if 0, otherwise
692  *	%MONITOR_FLAG_CHANGED will be set
693  * @use_4addr: use 4-address frames
694  * @macaddr: address to use for this virtual interface.
695  *	If this parameter is set to zero address the driver may
696  *	determine the address as needed.
697  *	This feature is only fully supported by drivers that enable the
698  *	%NL80211_FEATURE_MAC_ON_CREATE flag.  Others may support creating
699  **	only p2p devices with specified MAC.
700  * @vht_mumimo_groups: MU-MIMO groupID, used for monitoring MU-MIMO packets
701  *	belonging to that MU-MIMO groupID; %NULL if not changed
702  * @vht_mumimo_follow_addr: MU-MIMO follow address, used for monitoring
703  *	MU-MIMO packets going to the specified station; %NULL if not changed
704  */
705 struct vif_params {
706 	u32 flags;
707 	int use_4addr;
708 	u8 macaddr[ETH_ALEN];
709 	const u8 *vht_mumimo_groups;
710 	const u8 *vht_mumimo_follow_addr;
711 };
712 
713 /**
714  * struct key_params - key information
715  *
716  * Information about a key
717  *
718  * @key: key material
719  * @key_len: length of key material
720  * @cipher: cipher suite selector
721  * @seq: sequence counter (IV/PN) for TKIP and CCMP keys, only used
722  *	with the get_key() callback, must be in little endian,
723  *	length given by @seq_len.
724  * @seq_len: length of @seq.
725  * @vlan_id: vlan_id for VLAN group key (if nonzero)
726  * @mode: key install mode (RX_TX, NO_TX or SET_TX)
727  */
728 struct key_params {
729 	const u8 *key;
730 	const u8 *seq;
731 	int key_len;
732 	int seq_len;
733 	u16 vlan_id;
734 	u32 cipher;
735 	enum nl80211_key_mode mode;
736 };
737 
738 /**
739  * struct cfg80211_chan_def - channel definition
740  * @chan: the (control) channel
741  * @width: channel width
742  * @center_freq1: center frequency of first segment
743  * @center_freq2: center frequency of second segment
744  *	(only with 80+80 MHz)
745  * @edmg: define the EDMG channels configuration.
746  *	If edmg is requested (i.e. the .channels member is non-zero),
747  *	chan will define the primary channel and all other
748  *	parameters are ignored.
749  * @freq1_offset: offset from @center_freq1, in KHz
750  */
751 struct cfg80211_chan_def {
752 	struct ieee80211_channel *chan;
753 	enum nl80211_chan_width width;
754 	u32 center_freq1;
755 	u32 center_freq2;
756 	struct ieee80211_edmg edmg;
757 	u16 freq1_offset;
758 };
759 
760 /*
761  * cfg80211_bitrate_mask - masks for bitrate control
762  */
763 struct cfg80211_bitrate_mask {
764 	struct {
765 		u32 legacy;
766 		u8 ht_mcs[IEEE80211_HT_MCS_MASK_LEN];
767 		u16 vht_mcs[NL80211_VHT_NSS_MAX];
768 		u16 he_mcs[NL80211_HE_NSS_MAX];
769 		enum nl80211_txrate_gi gi;
770 		enum nl80211_he_gi he_gi;
771 		enum nl80211_he_ltf he_ltf;
772 	} control[NUM_NL80211_BANDS];
773 };
774 
775 
776 /**
777  * struct cfg80211_tid_cfg - TID specific configuration
778  * @config_override: Flag to notify driver to reset TID configuration
779  *	of the peer.
780  * @tids: bitmap of TIDs to modify
781  * @mask: bitmap of attributes indicating which parameter changed,
782  *	similar to &nl80211_tid_config_supp.
783  * @noack: noack configuration value for the TID
784  * @retry_long: retry count value
785  * @retry_short: retry count value
786  * @ampdu: Enable/Disable MPDU aggregation
787  * @rtscts: Enable/Disable RTS/CTS
788  * @amsdu: Enable/Disable MSDU aggregation
789  * @txrate_type: Tx bitrate mask type
790  * @txrate_mask: Tx bitrate to be applied for the TID
791  */
792 struct cfg80211_tid_cfg {
793 	bool config_override;
794 	u8 tids;
795 	u64 mask;
796 	enum nl80211_tid_config noack;
797 	u8 retry_long, retry_short;
798 	enum nl80211_tid_config ampdu;
799 	enum nl80211_tid_config rtscts;
800 	enum nl80211_tid_config amsdu;
801 	enum nl80211_tx_rate_setting txrate_type;
802 	struct cfg80211_bitrate_mask txrate_mask;
803 };
804 
805 /**
806  * struct cfg80211_tid_config - TID configuration
807  * @peer: Station's MAC address
808  * @n_tid_conf: Number of TID specific configurations to be applied
809  * @tid_conf: Configuration change info
810  */
811 struct cfg80211_tid_config {
812 	const u8 *peer;
813 	u32 n_tid_conf;
814 	struct cfg80211_tid_cfg tid_conf[] __counted_by(n_tid_conf);
815 };
816 
817 /**
818  * struct cfg80211_fils_aad - FILS AAD data
819  * @macaddr: STA MAC address
820  * @kek: FILS KEK
821  * @kek_len: FILS KEK length
822  * @snonce: STA Nonce
823  * @anonce: AP Nonce
824  */
825 struct cfg80211_fils_aad {
826 	const u8 *macaddr;
827 	const u8 *kek;
828 	u8 kek_len;
829 	const u8 *snonce;
830 	const u8 *anonce;
831 };
832 
833 /**
834  * struct cfg80211_set_hw_timestamp - enable/disable HW timestamping
835  * @macaddr: peer MAC address. NULL to enable/disable HW timestamping for all
836  *	addresses.
837  * @enable: if set, enable HW timestamping for the specified MAC address.
838  *	Otherwise disable HW timestamping for the specified MAC address.
839  */
840 struct cfg80211_set_hw_timestamp {
841 	const u8 *macaddr;
842 	bool enable;
843 };
844 
845 /**
846  * cfg80211_get_chandef_type - return old channel type from chandef
847  * @chandef: the channel definition
848  *
849  * Return: The old channel type (NOHT, HT20, HT40+/-) from a given
850  * chandef, which must have a bandwidth allowing this conversion.
851  */
852 static inline enum nl80211_channel_type
cfg80211_get_chandef_type(const struct cfg80211_chan_def * chandef)853 cfg80211_get_chandef_type(const struct cfg80211_chan_def *chandef)
854 {
855 	switch (chandef->width) {
856 	case NL80211_CHAN_WIDTH_20_NOHT:
857 		return NL80211_CHAN_NO_HT;
858 	case NL80211_CHAN_WIDTH_20:
859 		return NL80211_CHAN_HT20;
860 	case NL80211_CHAN_WIDTH_40:
861 		if (chandef->center_freq1 > chandef->chan->center_freq)
862 			return NL80211_CHAN_HT40PLUS;
863 		return NL80211_CHAN_HT40MINUS;
864 	default:
865 		WARN_ON(1);
866 		return NL80211_CHAN_NO_HT;
867 	}
868 }
869 
870 /**
871  * cfg80211_chandef_create - create channel definition using channel type
872  * @chandef: the channel definition struct to fill
873  * @channel: the control channel
874  * @chantype: the channel type
875  *
876  * Given a channel type, create a channel definition.
877  */
878 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
879 			     struct ieee80211_channel *channel,
880 			     enum nl80211_channel_type chantype);
881 
882 /**
883  * cfg80211_chandef_identical - check if two channel definitions are identical
884  * @chandef1: first channel definition
885  * @chandef2: second channel definition
886  *
887  * Return: %true if the channels defined by the channel definitions are
888  * identical, %false otherwise.
889  */
890 static inline bool
cfg80211_chandef_identical(const struct cfg80211_chan_def * chandef1,const struct cfg80211_chan_def * chandef2)891 cfg80211_chandef_identical(const struct cfg80211_chan_def *chandef1,
892 			   const struct cfg80211_chan_def *chandef2)
893 {
894 	return (chandef1->chan == chandef2->chan &&
895 		chandef1->width == chandef2->width &&
896 		chandef1->center_freq1 == chandef2->center_freq1 &&
897 		chandef1->freq1_offset == chandef2->freq1_offset &&
898 		chandef1->center_freq2 == chandef2->center_freq2);
899 }
900 
901 /**
902  * cfg80211_chandef_is_edmg - check if chandef represents an EDMG channel
903  *
904  * @chandef: the channel definition
905  *
906  * Return: %true if EDMG defined, %false otherwise.
907  */
908 static inline bool
cfg80211_chandef_is_edmg(const struct cfg80211_chan_def * chandef)909 cfg80211_chandef_is_edmg(const struct cfg80211_chan_def *chandef)
910 {
911 	return chandef->edmg.channels || chandef->edmg.bw_config;
912 }
913 
914 /**
915  * cfg80211_chandef_compatible - check if two channel definitions are compatible
916  * @chandef1: first channel definition
917  * @chandef2: second channel definition
918  *
919  * Return: %NULL if the given channel definitions are incompatible,
920  * chandef1 or chandef2 otherwise.
921  */
922 const struct cfg80211_chan_def *
923 cfg80211_chandef_compatible(const struct cfg80211_chan_def *chandef1,
924 			    const struct cfg80211_chan_def *chandef2);
925 
926 /**
927  * cfg80211_chandef_valid - check if a channel definition is valid
928  * @chandef: the channel definition to check
929  * Return: %true if the channel definition is valid. %false otherwise.
930  */
931 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef);
932 
933 /**
934  * cfg80211_chandef_usable - check if secondary channels can be used
935  * @wiphy: the wiphy to validate against
936  * @chandef: the channel definition to check
937  * @prohibited_flags: the regulatory channel flags that must not be set
938  * Return: %true if secondary channels are usable. %false otherwise.
939  */
940 bool cfg80211_chandef_usable(struct wiphy *wiphy,
941 			     const struct cfg80211_chan_def *chandef,
942 			     u32 prohibited_flags);
943 
944 /**
945  * cfg80211_chandef_dfs_required - checks if radar detection is required
946  * @wiphy: the wiphy to validate against
947  * @chandef: the channel definition to check
948  * @iftype: the interface type as specified in &enum nl80211_iftype
949  * Returns:
950  *	1 if radar detection is required, 0 if it is not, < 0 on error
951  */
952 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
953 				  const struct cfg80211_chan_def *chandef,
954 				  enum nl80211_iftype iftype);
955 
956 /**
957  * nl80211_send_chandef - sends the channel definition.
958  * @msg: the msg to send channel definition
959  * @chandef: the channel definition to check
960  *
961  * Returns: 0 if sent the channel definition to msg, < 0 on error
962  **/
963 int nl80211_send_chandef(struct sk_buff *msg, const struct cfg80211_chan_def *chandef);
964 
965 /**
966  * ieee80211_chanwidth_rate_flags - return rate flags for channel width
967  * @width: the channel width of the channel
968  *
969  * In some channel types, not all rates may be used - for example CCK
970  * rates may not be used in 5/10 MHz channels.
971  *
972  * Returns: rate flags which apply for this channel width
973  */
974 static inline enum ieee80211_rate_flags
ieee80211_chanwidth_rate_flags(enum nl80211_chan_width width)975 ieee80211_chanwidth_rate_flags(enum nl80211_chan_width width)
976 {
977 	switch (width) {
978 	case NL80211_CHAN_WIDTH_5:
979 		return IEEE80211_RATE_SUPPORTS_5MHZ;
980 	case NL80211_CHAN_WIDTH_10:
981 		return IEEE80211_RATE_SUPPORTS_10MHZ;
982 	default:
983 		break;
984 	}
985 	return 0;
986 }
987 
988 /**
989  * ieee80211_chandef_rate_flags - returns rate flags for a channel
990  * @chandef: channel definition for the channel
991  *
992  * See ieee80211_chanwidth_rate_flags().
993  *
994  * Returns: rate flags which apply for this channel
995  */
996 static inline enum ieee80211_rate_flags
ieee80211_chandef_rate_flags(struct cfg80211_chan_def * chandef)997 ieee80211_chandef_rate_flags(struct cfg80211_chan_def *chandef)
998 {
999 	return ieee80211_chanwidth_rate_flags(chandef->width);
1000 }
1001 
1002 /**
1003  * ieee80211_chandef_max_power - maximum transmission power for the chandef
1004  *
1005  * In some regulations, the transmit power may depend on the configured channel
1006  * bandwidth which may be defined as dBm/MHz. This function returns the actual
1007  * max_power for non-standard (20 MHz) channels.
1008  *
1009  * @chandef: channel definition for the channel
1010  *
1011  * Returns: maximum allowed transmission power in dBm for the chandef
1012  */
1013 static inline int
ieee80211_chandef_max_power(struct cfg80211_chan_def * chandef)1014 ieee80211_chandef_max_power(struct cfg80211_chan_def *chandef)
1015 {
1016 	switch (chandef->width) {
1017 	case NL80211_CHAN_WIDTH_5:
1018 		return min(chandef->chan->max_reg_power - 6,
1019 			   chandef->chan->max_power);
1020 	case NL80211_CHAN_WIDTH_10:
1021 		return min(chandef->chan->max_reg_power - 3,
1022 			   chandef->chan->max_power);
1023 	default:
1024 		break;
1025 	}
1026 	return chandef->chan->max_power;
1027 }
1028 
1029 /**
1030  * cfg80211_any_usable_channels - check for usable channels
1031  * @wiphy: the wiphy to check for
1032  * @band_mask: which bands to check on
1033  * @prohibited_flags: which channels to not consider usable,
1034  *	%IEEE80211_CHAN_DISABLED is always taken into account
1035  */
1036 bool cfg80211_any_usable_channels(struct wiphy *wiphy,
1037 				  unsigned long band_mask,
1038 				  u32 prohibited_flags);
1039 
1040 /**
1041  * enum survey_info_flags - survey information flags
1042  *
1043  * @SURVEY_INFO_NOISE_DBM: noise (in dBm) was filled in
1044  * @SURVEY_INFO_IN_USE: channel is currently being used
1045  * @SURVEY_INFO_TIME: active time (in ms) was filled in
1046  * @SURVEY_INFO_TIME_BUSY: busy time was filled in
1047  * @SURVEY_INFO_TIME_EXT_BUSY: extension channel busy time was filled in
1048  * @SURVEY_INFO_TIME_RX: receive time was filled in
1049  * @SURVEY_INFO_TIME_TX: transmit time was filled in
1050  * @SURVEY_INFO_TIME_SCAN: scan time was filled in
1051  * @SURVEY_INFO_TIME_BSS_RX: local BSS receive time was filled in
1052  *
1053  * Used by the driver to indicate which info in &struct survey_info
1054  * it has filled in during the get_survey().
1055  */
1056 enum survey_info_flags {
1057 	SURVEY_INFO_NOISE_DBM		= BIT(0),
1058 	SURVEY_INFO_IN_USE		= BIT(1),
1059 	SURVEY_INFO_TIME		= BIT(2),
1060 	SURVEY_INFO_TIME_BUSY		= BIT(3),
1061 	SURVEY_INFO_TIME_EXT_BUSY	= BIT(4),
1062 	SURVEY_INFO_TIME_RX		= BIT(5),
1063 	SURVEY_INFO_TIME_TX		= BIT(6),
1064 	SURVEY_INFO_TIME_SCAN		= BIT(7),
1065 	SURVEY_INFO_TIME_BSS_RX		= BIT(8),
1066 };
1067 
1068 /**
1069  * struct survey_info - channel survey response
1070  *
1071  * @channel: the channel this survey record reports, may be %NULL for a single
1072  *	record to report global statistics
1073  * @filled: bitflag of flags from &enum survey_info_flags
1074  * @noise: channel noise in dBm. This and all following fields are
1075  *	optional
1076  * @time: amount of time in ms the radio was turn on (on the channel)
1077  * @time_busy: amount of time the primary channel was sensed busy
1078  * @time_ext_busy: amount of time the extension channel was sensed busy
1079  * @time_rx: amount of time the radio spent receiving data
1080  * @time_tx: amount of time the radio spent transmitting data
1081  * @time_scan: amount of time the radio spent for scanning
1082  * @time_bss_rx: amount of time the radio spent receiving data on a local BSS
1083  *
1084  * Used by dump_survey() to report back per-channel survey information.
1085  *
1086  * This structure can later be expanded with things like
1087  * channel duty cycle etc.
1088  */
1089 struct survey_info {
1090 	struct ieee80211_channel *channel;
1091 	u64 time;
1092 	u64 time_busy;
1093 	u64 time_ext_busy;
1094 	u64 time_rx;
1095 	u64 time_tx;
1096 	u64 time_scan;
1097 	u64 time_bss_rx;
1098 	u32 filled;
1099 	s8 noise;
1100 };
1101 
1102 #define CFG80211_MAX_NUM_AKM_SUITES	10
1103 
1104 /**
1105  * struct cfg80211_crypto_settings - Crypto settings
1106  * @wpa_versions: indicates which, if any, WPA versions are enabled
1107  *	(from enum nl80211_wpa_versions)
1108  * @cipher_group: group key cipher suite (or 0 if unset)
1109  * @n_ciphers_pairwise: number of AP supported unicast ciphers
1110  * @ciphers_pairwise: unicast key cipher suites
1111  * @n_akm_suites: number of AKM suites
1112  * @akm_suites: AKM suites
1113  * @control_port: Whether user space controls IEEE 802.1X port, i.e.,
1114  *	sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is
1115  *	required to assume that the port is unauthorized until authorized by
1116  *	user space. Otherwise, port is marked authorized by default.
1117  * @control_port_ethertype: the control port protocol that should be
1118  *	allowed through even on unauthorized ports
1119  * @control_port_no_encrypt: TRUE to prevent encryption of control port
1120  *	protocol frames.
1121  * @control_port_over_nl80211: TRUE if userspace expects to exchange control
1122  *	port frames over NL80211 instead of the network interface.
1123  * @control_port_no_preauth: disables pre-auth rx over the nl80211 control
1124  *	port for mac80211
1125  * @psk: PSK (for devices supporting 4-way-handshake offload)
1126  * @sae_pwd: password for SAE authentication (for devices supporting SAE
1127  *	offload)
1128  * @sae_pwd_len: length of SAE password (for devices supporting SAE offload)
1129  * @sae_pwe: The mechanisms allowed for SAE PWE derivation:
1130  *
1131  *	NL80211_SAE_PWE_UNSPECIFIED
1132  *	  Not-specified, used to indicate userspace did not specify any
1133  *	  preference. The driver should follow its internal policy in
1134  *	  such a scenario.
1135  *
1136  *	NL80211_SAE_PWE_HUNT_AND_PECK
1137  *	  Allow hunting-and-pecking loop only
1138  *
1139  *	NL80211_SAE_PWE_HASH_TO_ELEMENT
1140  *	  Allow hash-to-element only
1141  *
1142  *	NL80211_SAE_PWE_BOTH
1143  *	  Allow either hunting-and-pecking loop or hash-to-element
1144  */
1145 struct cfg80211_crypto_settings {
1146 	u32 wpa_versions;
1147 	u32 cipher_group;
1148 	int n_ciphers_pairwise;
1149 	u32 ciphers_pairwise[NL80211_MAX_NR_CIPHER_SUITES];
1150 	int n_akm_suites;
1151 	u32 akm_suites[CFG80211_MAX_NUM_AKM_SUITES];
1152 	bool control_port;
1153 	__be16 control_port_ethertype;
1154 	bool control_port_no_encrypt;
1155 	bool control_port_over_nl80211;
1156 	bool control_port_no_preauth;
1157 	const u8 *psk;
1158 	const u8 *sae_pwd;
1159 	u8 sae_pwd_len;
1160 	enum nl80211_sae_pwe_mechanism sae_pwe;
1161 };
1162 
1163 /**
1164  * struct cfg80211_mbssid_config - AP settings for multi bssid
1165  *
1166  * @tx_wdev: pointer to the transmitted interface in the MBSSID set
1167  * @index: index of this AP in the multi bssid group.
1168  * @ema: set to true if the beacons should be sent out in EMA mode.
1169  */
1170 struct cfg80211_mbssid_config {
1171 	struct wireless_dev *tx_wdev;
1172 	u8 index;
1173 	bool ema;
1174 };
1175 
1176 /**
1177  * struct cfg80211_mbssid_elems - Multiple BSSID elements
1178  *
1179  * @cnt: Number of elements in array %elems.
1180  *
1181  * @elem: Array of multiple BSSID element(s) to be added into Beacon frames.
1182  * @elem.data: Data for multiple BSSID elements.
1183  * @elem.len: Length of data.
1184  */
1185 struct cfg80211_mbssid_elems {
1186 	u8 cnt;
1187 	struct {
1188 		const u8 *data;
1189 		size_t len;
1190 	} elem[] __counted_by(cnt);
1191 };
1192 
1193 /**
1194  * struct cfg80211_rnr_elems - Reduced neighbor report (RNR) elements
1195  *
1196  * @cnt: Number of elements in array %elems.
1197  *
1198  * @elem: Array of RNR element(s) to be added into Beacon frames.
1199  * @elem.data: Data for RNR elements.
1200  * @elem.len: Length of data.
1201  */
1202 struct cfg80211_rnr_elems {
1203 	u8 cnt;
1204 	struct {
1205 		const u8 *data;
1206 		size_t len;
1207 	} elem[] __counted_by(cnt);
1208 };
1209 
1210 /**
1211  * struct cfg80211_beacon_data - beacon data
1212  * @link_id: the link ID for the AP MLD link sending this beacon
1213  * @head: head portion of beacon (before TIM IE)
1214  *	or %NULL if not changed
1215  * @tail: tail portion of beacon (after TIM IE)
1216  *	or %NULL if not changed
1217  * @head_len: length of @head
1218  * @tail_len: length of @tail
1219  * @beacon_ies: extra information element(s) to add into Beacon frames or %NULL
1220  * @beacon_ies_len: length of beacon_ies in octets
1221  * @proberesp_ies: extra information element(s) to add into Probe Response
1222  *	frames or %NULL
1223  * @proberesp_ies_len: length of proberesp_ies in octets
1224  * @assocresp_ies: extra information element(s) to add into (Re)Association
1225  *	Response frames or %NULL
1226  * @assocresp_ies_len: length of assocresp_ies in octets
1227  * @probe_resp_len: length of probe response template (@probe_resp)
1228  * @probe_resp: probe response template (AP mode only)
1229  * @mbssid_ies: multiple BSSID elements
1230  * @rnr_ies: reduced neighbor report elements
1231  * @ftm_responder: enable FTM responder functionality; -1 for no change
1232  *	(which also implies no change in LCI/civic location data)
1233  * @lci: Measurement Report element content, starting with Measurement Token
1234  *	(measurement type 8)
1235  * @civicloc: Measurement Report element content, starting with Measurement
1236  *	Token (measurement type 11)
1237  * @lci_len: LCI data length
1238  * @civicloc_len: Civic location data length
1239  * @he_bss_color: BSS Color settings
1240  * @he_bss_color_valid: indicates whether bss color
1241  *	attribute is present in beacon data or not.
1242  */
1243 struct cfg80211_beacon_data {
1244 	unsigned int link_id;
1245 
1246 	const u8 *head, *tail;
1247 	const u8 *beacon_ies;
1248 	const u8 *proberesp_ies;
1249 	const u8 *assocresp_ies;
1250 	const u8 *probe_resp;
1251 	const u8 *lci;
1252 	const u8 *civicloc;
1253 	struct cfg80211_mbssid_elems *mbssid_ies;
1254 	struct cfg80211_rnr_elems *rnr_ies;
1255 	s8 ftm_responder;
1256 
1257 	size_t head_len, tail_len;
1258 	size_t beacon_ies_len;
1259 	size_t proberesp_ies_len;
1260 	size_t assocresp_ies_len;
1261 	size_t probe_resp_len;
1262 	size_t lci_len;
1263 	size_t civicloc_len;
1264 	struct cfg80211_he_bss_color he_bss_color;
1265 	bool he_bss_color_valid;
1266 };
1267 
1268 struct mac_address {
1269 	u8 addr[ETH_ALEN];
1270 };
1271 
1272 /**
1273  * struct cfg80211_acl_data - Access control list data
1274  *
1275  * @acl_policy: ACL policy to be applied on the station's
1276  *	entry specified by mac_addr
1277  * @n_acl_entries: Number of MAC address entries passed
1278  * @mac_addrs: List of MAC addresses of stations to be used for ACL
1279  */
1280 struct cfg80211_acl_data {
1281 	enum nl80211_acl_policy acl_policy;
1282 	int n_acl_entries;
1283 
1284 	/* Keep it last */
1285 	struct mac_address mac_addrs[] __counted_by(n_acl_entries);
1286 };
1287 
1288 /**
1289  * struct cfg80211_fils_discovery - FILS discovery parameters from
1290  * IEEE Std 802.11ai-2016, Annex C.3 MIB detail.
1291  *
1292  * @min_interval: Minimum packet interval in TUs (0 - 10000)
1293  * @max_interval: Maximum packet interval in TUs (0 - 10000)
1294  * @tmpl_len: Template length
1295  * @tmpl: Template data for FILS discovery frame including the action
1296  *	frame headers.
1297  */
1298 struct cfg80211_fils_discovery {
1299 	u32 min_interval;
1300 	u32 max_interval;
1301 	size_t tmpl_len;
1302 	const u8 *tmpl;
1303 };
1304 
1305 /**
1306  * struct cfg80211_unsol_bcast_probe_resp - Unsolicited broadcast probe
1307  *	response parameters in 6GHz.
1308  *
1309  * @interval: Packet interval in TUs. Maximum allowed is 20 TU, as mentioned
1310  *	in IEEE P802.11ax/D6.0 26.17.2.3.2 - AP behavior for fast passive
1311  *	scanning
1312  * @tmpl_len: Template length
1313  * @tmpl: Template data for probe response
1314  */
1315 struct cfg80211_unsol_bcast_probe_resp {
1316 	u32 interval;
1317 	size_t tmpl_len;
1318 	const u8 *tmpl;
1319 };
1320 
1321 /**
1322  * struct cfg80211_ap_settings - AP configuration
1323  *
1324  * Used to configure an AP interface.
1325  *
1326  * @chandef: defines the channel to use
1327  * @beacon: beacon data
1328  * @beacon_interval: beacon interval
1329  * @dtim_period: DTIM period
1330  * @ssid: SSID to be used in the BSS (note: may be %NULL if not provided from
1331  *	user space)
1332  * @ssid_len: length of @ssid
1333  * @hidden_ssid: whether to hide the SSID in Beacon/Probe Response frames
1334  * @crypto: crypto settings
1335  * @privacy: the BSS uses privacy
1336  * @auth_type: Authentication type (algorithm)
1337  * @smps_mode: SMPS mode
1338  * @inactivity_timeout: time in seconds to determine station's inactivity.
1339  * @p2p_ctwindow: P2P CT Window
1340  * @p2p_opp_ps: P2P opportunistic PS
1341  * @acl: ACL configuration used by the drivers which has support for
1342  *	MAC address based access control
1343  * @pbss: If set, start as a PCP instead of AP. Relevant for DMG
1344  *	networks.
1345  * @beacon_rate: bitrate to be used for beacons
1346  * @ht_cap: HT capabilities (or %NULL if HT isn't enabled)
1347  * @vht_cap: VHT capabilities (or %NULL if VHT isn't enabled)
1348  * @he_cap: HE capabilities (or %NULL if HE isn't enabled)
1349  * @eht_cap: EHT capabilities (or %NULL if EHT isn't enabled)
1350  * @eht_oper: EHT operation IE (or %NULL if EHT isn't enabled)
1351  * @ht_required: stations must support HT
1352  * @vht_required: stations must support VHT
1353  * @twt_responder: Enable Target Wait Time
1354  * @he_required: stations must support HE
1355  * @sae_h2e_required: stations must support direct H2E technique in SAE
1356  * @flags: flags, as defined in &enum nl80211_ap_settings_flags
1357  * @he_obss_pd: OBSS Packet Detection settings
1358  * @he_oper: HE operation IE (or %NULL if HE isn't enabled)
1359  * @fils_discovery: FILS discovery transmission parameters
1360  * @unsol_bcast_probe_resp: Unsolicited broadcast probe response parameters
1361  * @mbssid_config: AP settings for multiple bssid
1362  * @punct_bitmap: Preamble puncturing bitmap. Each bit represents
1363  *	a 20 MHz channel, lowest bit corresponding to the lowest channel.
1364  *	Bit set to 1 indicates that the channel is punctured.
1365  */
1366 struct cfg80211_ap_settings {
1367 	struct cfg80211_chan_def chandef;
1368 
1369 	struct cfg80211_beacon_data beacon;
1370 
1371 	int beacon_interval, dtim_period;
1372 	const u8 *ssid;
1373 	size_t ssid_len;
1374 	enum nl80211_hidden_ssid hidden_ssid;
1375 	struct cfg80211_crypto_settings crypto;
1376 	bool privacy;
1377 	enum nl80211_auth_type auth_type;
1378 	enum nl80211_smps_mode smps_mode;
1379 	int inactivity_timeout;
1380 	u8 p2p_ctwindow;
1381 	bool p2p_opp_ps;
1382 	const struct cfg80211_acl_data *acl;
1383 	bool pbss;
1384 	struct cfg80211_bitrate_mask beacon_rate;
1385 
1386 	const struct ieee80211_ht_cap *ht_cap;
1387 	const struct ieee80211_vht_cap *vht_cap;
1388 	const struct ieee80211_he_cap_elem *he_cap;
1389 	const struct ieee80211_he_operation *he_oper;
1390 	const struct ieee80211_eht_cap_elem *eht_cap;
1391 	const struct ieee80211_eht_operation *eht_oper;
1392 	bool ht_required, vht_required, he_required, sae_h2e_required;
1393 	bool twt_responder;
1394 	u32 flags;
1395 	struct ieee80211_he_obss_pd he_obss_pd;
1396 	struct cfg80211_fils_discovery fils_discovery;
1397 	struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
1398 	struct cfg80211_mbssid_config mbssid_config;
1399 	u16 punct_bitmap;
1400 };
1401 
1402 /**
1403  * struct cfg80211_csa_settings - channel switch settings
1404  *
1405  * Used for channel switch
1406  *
1407  * @chandef: defines the channel to use after the switch
1408  * @beacon_csa: beacon data while performing the switch
1409  * @counter_offsets_beacon: offsets of the counters within the beacon (tail)
1410  * @counter_offsets_presp: offsets of the counters within the probe response
1411  * @n_counter_offsets_beacon: number of csa counters the beacon (tail)
1412  * @n_counter_offsets_presp: number of csa counters in the probe response
1413  * @beacon_after: beacon data to be used on the new channel
1414  * @radar_required: whether radar detection is required on the new channel
1415  * @block_tx: whether transmissions should be blocked while changing
1416  * @count: number of beacons until switch
1417  * @punct_bitmap: Preamble puncturing bitmap. Each bit represents
1418  *	a 20 MHz channel, lowest bit corresponding to the lowest channel.
1419  *	Bit set to 1 indicates that the channel is punctured.
1420  */
1421 struct cfg80211_csa_settings {
1422 	struct cfg80211_chan_def chandef;
1423 	struct cfg80211_beacon_data beacon_csa;
1424 	const u16 *counter_offsets_beacon;
1425 	const u16 *counter_offsets_presp;
1426 	unsigned int n_counter_offsets_beacon;
1427 	unsigned int n_counter_offsets_presp;
1428 	struct cfg80211_beacon_data beacon_after;
1429 	bool radar_required;
1430 	bool block_tx;
1431 	u8 count;
1432 	u16 punct_bitmap;
1433 };
1434 
1435 /**
1436  * struct cfg80211_color_change_settings - color change settings
1437  *
1438  * Used for bss color change
1439  *
1440  * @beacon_color_change: beacon data while performing the color countdown
1441  * @counter_offset_beacon: offsets of the counters within the beacon (tail)
1442  * @counter_offset_presp: offsets of the counters within the probe response
1443  * @beacon_next: beacon data to be used after the color change
1444  * @count: number of beacons until the color change
1445  * @color: the color used after the change
1446  */
1447 struct cfg80211_color_change_settings {
1448 	struct cfg80211_beacon_data beacon_color_change;
1449 	u16 counter_offset_beacon;
1450 	u16 counter_offset_presp;
1451 	struct cfg80211_beacon_data beacon_next;
1452 	u8 count;
1453 	u8 color;
1454 };
1455 
1456 /**
1457  * struct iface_combination_params - input parameters for interface combinations
1458  *
1459  * Used to pass interface combination parameters
1460  *
1461  * @num_different_channels: the number of different channels we want
1462  *	to use for verification
1463  * @radar_detect: a bitmap where each bit corresponds to a channel
1464  *	width where radar detection is needed, as in the definition of
1465  *	&struct ieee80211_iface_combination.@radar_detect_widths
1466  * @iftype_num: array with the number of interfaces of each interface
1467  *	type.  The index is the interface type as specified in &enum
1468  *	nl80211_iftype.
1469  * @new_beacon_int: set this to the beacon interval of a new interface
1470  *	that's not operating yet, if such is to be checked as part of
1471  *	the verification
1472  */
1473 struct iface_combination_params {
1474 	int num_different_channels;
1475 	u8 radar_detect;
1476 	int iftype_num[NUM_NL80211_IFTYPES];
1477 	u32 new_beacon_int;
1478 };
1479 
1480 /**
1481  * enum station_parameters_apply_mask - station parameter values to apply
1482  * @STATION_PARAM_APPLY_UAPSD: apply new uAPSD parameters (uapsd_queues, max_sp)
1483  * @STATION_PARAM_APPLY_CAPABILITY: apply new capability
1484  * @STATION_PARAM_APPLY_PLINK_STATE: apply new plink state
1485  *
1486  * Not all station parameters have in-band "no change" signalling,
1487  * for those that don't these flags will are used.
1488  */
1489 enum station_parameters_apply_mask {
1490 	STATION_PARAM_APPLY_UAPSD = BIT(0),
1491 	STATION_PARAM_APPLY_CAPABILITY = BIT(1),
1492 	STATION_PARAM_APPLY_PLINK_STATE = BIT(2),
1493 };
1494 
1495 /**
1496  * struct sta_txpwr - station txpower configuration
1497  *
1498  * Used to configure txpower for station.
1499  *
1500  * @power: tx power (in dBm) to be used for sending data traffic. If tx power
1501  *	is not provided, the default per-interface tx power setting will be
1502  *	overriding. Driver should be picking up the lowest tx power, either tx
1503  *	power per-interface or per-station.
1504  * @type: In particular if TPC %type is NL80211_TX_POWER_LIMITED then tx power
1505  *	will be less than or equal to specified from userspace, whereas if TPC
1506  *	%type is NL80211_TX_POWER_AUTOMATIC then it indicates default tx power.
1507  *	NL80211_TX_POWER_FIXED is not a valid configuration option for
1508  *	per peer TPC.
1509  */
1510 struct sta_txpwr {
1511 	s16 power;
1512 	enum nl80211_tx_power_setting type;
1513 };
1514 
1515 /**
1516  * struct link_station_parameters - link station parameters
1517  *
1518  * Used to change and create a new link station.
1519  *
1520  * @mld_mac: MAC address of the station
1521  * @link_id: the link id (-1 for non-MLD station)
1522  * @link_mac: MAC address of the link
1523  * @supported_rates: supported rates in IEEE 802.11 format
1524  *	(or NULL for no change)
1525  * @supported_rates_len: number of supported rates
1526  * @ht_capa: HT capabilities of station
1527  * @vht_capa: VHT capabilities of station
1528  * @opmode_notif: operating mode field from Operating Mode Notification
1529  * @opmode_notif_used: information if operating mode field is used
1530  * @he_capa: HE capabilities of station
1531  * @he_capa_len: the length of the HE capabilities
1532  * @txpwr: transmit power for an associated station
1533  * @txpwr_set: txpwr field is set
1534  * @he_6ghz_capa: HE 6 GHz Band capabilities of station
1535  * @eht_capa: EHT capabilities of station
1536  * @eht_capa_len: the length of the EHT capabilities
1537  */
1538 struct link_station_parameters {
1539 	const u8 *mld_mac;
1540 	int link_id;
1541 	const u8 *link_mac;
1542 	const u8 *supported_rates;
1543 	u8 supported_rates_len;
1544 	const struct ieee80211_ht_cap *ht_capa;
1545 	const struct ieee80211_vht_cap *vht_capa;
1546 	u8 opmode_notif;
1547 	bool opmode_notif_used;
1548 	const struct ieee80211_he_cap_elem *he_capa;
1549 	u8 he_capa_len;
1550 	struct sta_txpwr txpwr;
1551 	bool txpwr_set;
1552 	const struct ieee80211_he_6ghz_capa *he_6ghz_capa;
1553 	const struct ieee80211_eht_cap_elem *eht_capa;
1554 	u8 eht_capa_len;
1555 };
1556 
1557 /**
1558  * struct link_station_del_parameters - link station deletion parameters
1559  *
1560  * Used to delete a link station entry (or all stations).
1561  *
1562  * @mld_mac: MAC address of the station
1563  * @link_id: the link id
1564  */
1565 struct link_station_del_parameters {
1566 	const u8 *mld_mac;
1567 	u32 link_id;
1568 };
1569 
1570 /**
1571  * struct station_parameters - station parameters
1572  *
1573  * Used to change and create a new station.
1574  *
1575  * @vlan: vlan interface station should belong to
1576  * @sta_flags_mask: station flags that changed
1577  *	(bitmask of BIT(%NL80211_STA_FLAG_...))
1578  * @sta_flags_set: station flags values
1579  *	(bitmask of BIT(%NL80211_STA_FLAG_...))
1580  * @listen_interval: listen interval or -1 for no change
1581  * @aid: AID or zero for no change
1582  * @vlan_id: VLAN ID for station (if nonzero)
1583  * @peer_aid: mesh peer AID or zero for no change
1584  * @plink_action: plink action to take
1585  * @plink_state: set the peer link state for a station
1586  * @uapsd_queues: bitmap of queues configured for uapsd. same format
1587  *	as the AC bitmap in the QoS info field
1588  * @max_sp: max Service Period. same format as the MAX_SP in the
1589  *	QoS info field (but already shifted down)
1590  * @sta_modify_mask: bitmap indicating which parameters changed
1591  *	(for those that don't have a natural "no change" value),
1592  *	see &enum station_parameters_apply_mask
1593  * @local_pm: local link-specific mesh power save mode (no change when set
1594  *	to unknown)
1595  * @capability: station capability
1596  * @ext_capab: extended capabilities of the station
1597  * @ext_capab_len: number of extended capabilities
1598  * @supported_channels: supported channels in IEEE 802.11 format
1599  * @supported_channels_len: number of supported channels
1600  * @supported_oper_classes: supported oper classes in IEEE 802.11 format
1601  * @supported_oper_classes_len: number of supported operating classes
1602  * @support_p2p_ps: information if station supports P2P PS mechanism
1603  * @airtime_weight: airtime scheduler weight for this station
1604  * @link_sta_params: link related params.
1605  */
1606 struct station_parameters {
1607 	struct net_device *vlan;
1608 	u32 sta_flags_mask, sta_flags_set;
1609 	u32 sta_modify_mask;
1610 	int listen_interval;
1611 	u16 aid;
1612 	u16 vlan_id;
1613 	u16 peer_aid;
1614 	u8 plink_action;
1615 	u8 plink_state;
1616 	u8 uapsd_queues;
1617 	u8 max_sp;
1618 	enum nl80211_mesh_power_mode local_pm;
1619 	u16 capability;
1620 	const u8 *ext_capab;
1621 	u8 ext_capab_len;
1622 	const u8 *supported_channels;
1623 	u8 supported_channels_len;
1624 	const u8 *supported_oper_classes;
1625 	u8 supported_oper_classes_len;
1626 	int support_p2p_ps;
1627 	u16 airtime_weight;
1628 	struct link_station_parameters link_sta_params;
1629 };
1630 
1631 /**
1632  * struct station_del_parameters - station deletion parameters
1633  *
1634  * Used to delete a station entry (or all stations).
1635  *
1636  * @mac: MAC address of the station to remove or NULL to remove all stations
1637  * @subtype: Management frame subtype to use for indicating removal
1638  *	(10 = Disassociation, 12 = Deauthentication)
1639  * @reason_code: Reason code for the Disassociation/Deauthentication frame
1640  */
1641 struct station_del_parameters {
1642 	const u8 *mac;
1643 	u8 subtype;
1644 	u16 reason_code;
1645 };
1646 
1647 /**
1648  * enum cfg80211_station_type - the type of station being modified
1649  * @CFG80211_STA_AP_CLIENT: client of an AP interface
1650  * @CFG80211_STA_AP_CLIENT_UNASSOC: client of an AP interface that is still
1651  *	unassociated (update properties for this type of client is permitted)
1652  * @CFG80211_STA_AP_MLME_CLIENT: client of an AP interface that has
1653  *	the AP MLME in the device
1654  * @CFG80211_STA_AP_STA: AP station on managed interface
1655  * @CFG80211_STA_IBSS: IBSS station
1656  * @CFG80211_STA_TDLS_PEER_SETUP: TDLS peer on managed interface (dummy entry
1657  *	while TDLS setup is in progress, it moves out of this state when
1658  *	being marked authorized; use this only if TDLS with external setup is
1659  *	supported/used)
1660  * @CFG80211_STA_TDLS_PEER_ACTIVE: TDLS peer on managed interface (active
1661  *	entry that is operating, has been marked authorized by userspace)
1662  * @CFG80211_STA_MESH_PEER_KERNEL: peer on mesh interface (kernel managed)
1663  * @CFG80211_STA_MESH_PEER_USER: peer on mesh interface (user managed)
1664  */
1665 enum cfg80211_station_type {
1666 	CFG80211_STA_AP_CLIENT,
1667 	CFG80211_STA_AP_CLIENT_UNASSOC,
1668 	CFG80211_STA_AP_MLME_CLIENT,
1669 	CFG80211_STA_AP_STA,
1670 	CFG80211_STA_IBSS,
1671 	CFG80211_STA_TDLS_PEER_SETUP,
1672 	CFG80211_STA_TDLS_PEER_ACTIVE,
1673 	CFG80211_STA_MESH_PEER_KERNEL,
1674 	CFG80211_STA_MESH_PEER_USER,
1675 };
1676 
1677 /**
1678  * cfg80211_check_station_change - validate parameter changes
1679  * @wiphy: the wiphy this operates on
1680  * @params: the new parameters for a station
1681  * @statype: the type of station being modified
1682  *
1683  * Utility function for the @change_station driver method. Call this function
1684  * with the appropriate station type looking up the station (and checking that
1685  * it exists). It will verify whether the station change is acceptable, and if
1686  * not will return an error code. Note that it may modify the parameters for
1687  * backward compatibility reasons, so don't use them before calling this.
1688  */
1689 int cfg80211_check_station_change(struct wiphy *wiphy,
1690 				  struct station_parameters *params,
1691 				  enum cfg80211_station_type statype);
1692 
1693 /**
1694  * enum rate_info_flags - bitrate info flags
1695  *
1696  * Used by the driver to indicate the specific rate transmission
1697  * type for 802.11n transmissions.
1698  *
1699  * @RATE_INFO_FLAGS_MCS: mcs field filled with HT MCS
1700  * @RATE_INFO_FLAGS_VHT_MCS: mcs field filled with VHT MCS
1701  * @RATE_INFO_FLAGS_SHORT_GI: 400ns guard interval
1702  * @RATE_INFO_FLAGS_DMG: 60GHz MCS
1703  * @RATE_INFO_FLAGS_HE_MCS: HE MCS information
1704  * @RATE_INFO_FLAGS_EDMG: 60GHz MCS in EDMG mode
1705  * @RATE_INFO_FLAGS_EXTENDED_SC_DMG: 60GHz extended SC MCS
1706  * @RATE_INFO_FLAGS_EHT_MCS: EHT MCS information
1707  * @RATE_INFO_FLAGS_S1G_MCS: MCS field filled with S1G MCS
1708  */
1709 enum rate_info_flags {
1710 	RATE_INFO_FLAGS_MCS			= BIT(0),
1711 	RATE_INFO_FLAGS_VHT_MCS			= BIT(1),
1712 	RATE_INFO_FLAGS_SHORT_GI		= BIT(2),
1713 	RATE_INFO_FLAGS_DMG			= BIT(3),
1714 	RATE_INFO_FLAGS_HE_MCS			= BIT(4),
1715 	RATE_INFO_FLAGS_EDMG			= BIT(5),
1716 	RATE_INFO_FLAGS_EXTENDED_SC_DMG		= BIT(6),
1717 	RATE_INFO_FLAGS_EHT_MCS			= BIT(7),
1718 	RATE_INFO_FLAGS_S1G_MCS			= BIT(8),
1719 };
1720 
1721 /**
1722  * enum rate_info_bw - rate bandwidth information
1723  *
1724  * Used by the driver to indicate the rate bandwidth.
1725  *
1726  * @RATE_INFO_BW_5: 5 MHz bandwidth
1727  * @RATE_INFO_BW_10: 10 MHz bandwidth
1728  * @RATE_INFO_BW_20: 20 MHz bandwidth
1729  * @RATE_INFO_BW_40: 40 MHz bandwidth
1730  * @RATE_INFO_BW_80: 80 MHz bandwidth
1731  * @RATE_INFO_BW_160: 160 MHz bandwidth
1732  * @RATE_INFO_BW_HE_RU: bandwidth determined by HE RU allocation
1733  * @RATE_INFO_BW_320: 320 MHz bandwidth
1734  * @RATE_INFO_BW_EHT_RU: bandwidth determined by EHT RU allocation
1735  * @RATE_INFO_BW_1: 1 MHz bandwidth
1736  * @RATE_INFO_BW_2: 2 MHz bandwidth
1737  * @RATE_INFO_BW_4: 4 MHz bandwidth
1738  * @RATE_INFO_BW_8: 8 MHz bandwidth
1739  * @RATE_INFO_BW_16: 16 MHz bandwidth
1740  */
1741 enum rate_info_bw {
1742 	RATE_INFO_BW_20 = 0,
1743 	RATE_INFO_BW_5,
1744 	RATE_INFO_BW_10,
1745 	RATE_INFO_BW_40,
1746 	RATE_INFO_BW_80,
1747 	RATE_INFO_BW_160,
1748 	RATE_INFO_BW_HE_RU,
1749 	RATE_INFO_BW_320,
1750 	RATE_INFO_BW_EHT_RU,
1751 	RATE_INFO_BW_1,
1752 	RATE_INFO_BW_2,
1753 	RATE_INFO_BW_4,
1754 	RATE_INFO_BW_8,
1755 	RATE_INFO_BW_16,
1756 };
1757 
1758 /**
1759  * struct rate_info - bitrate information
1760  *
1761  * Information about a receiving or transmitting bitrate
1762  *
1763  * @flags: bitflag of flags from &enum rate_info_flags
1764  * @legacy: bitrate in 100kbit/s for 802.11abg
1765  * @mcs: mcs index if struct describes an HT/VHT/HE/EHT/S1G rate
1766  * @nss: number of streams (VHT & HE only)
1767  * @bw: bandwidth (from &enum rate_info_bw)
1768  * @he_gi: HE guard interval (from &enum nl80211_he_gi)
1769  * @he_dcm: HE DCM value
1770  * @he_ru_alloc: HE RU allocation (from &enum nl80211_he_ru_alloc,
1771  *	only valid if bw is %RATE_INFO_BW_HE_RU)
1772  * @n_bonded_ch: In case of EDMG the number of bonded channels (1-4)
1773  * @eht_gi: EHT guard interval (from &enum nl80211_eht_gi)
1774  * @eht_ru_alloc: EHT RU allocation (from &enum nl80211_eht_ru_alloc,
1775  *	only valid if bw is %RATE_INFO_BW_EHT_RU)
1776  */
1777 struct rate_info {
1778 	u16 flags;
1779 	u16 legacy;
1780 	u8 mcs;
1781 	u8 nss;
1782 	u8 bw;
1783 	u8 he_gi;
1784 	u8 he_dcm;
1785 	u8 he_ru_alloc;
1786 	u8 n_bonded_ch;
1787 	u8 eht_gi;
1788 	u8 eht_ru_alloc;
1789 };
1790 
1791 /**
1792  * enum bss_param_flags - bitrate info flags
1793  *
1794  * Used by the driver to indicate the specific rate transmission
1795  * type for 802.11n transmissions.
1796  *
1797  * @BSS_PARAM_FLAGS_CTS_PROT: whether CTS protection is enabled
1798  * @BSS_PARAM_FLAGS_SHORT_PREAMBLE: whether short preamble is enabled
1799  * @BSS_PARAM_FLAGS_SHORT_SLOT_TIME: whether short slot time is enabled
1800  */
1801 enum bss_param_flags {
1802 	BSS_PARAM_FLAGS_CTS_PROT	= 1<<0,
1803 	BSS_PARAM_FLAGS_SHORT_PREAMBLE	= 1<<1,
1804 	BSS_PARAM_FLAGS_SHORT_SLOT_TIME	= 1<<2,
1805 };
1806 
1807 /**
1808  * struct sta_bss_parameters - BSS parameters for the attached station
1809  *
1810  * Information about the currently associated BSS
1811  *
1812  * @flags: bitflag of flags from &enum bss_param_flags
1813  * @dtim_period: DTIM period for the BSS
1814  * @beacon_interval: beacon interval
1815  */
1816 struct sta_bss_parameters {
1817 	u8 flags;
1818 	u8 dtim_period;
1819 	u16 beacon_interval;
1820 };
1821 
1822 /**
1823  * struct cfg80211_txq_stats - TXQ statistics for this TID
1824  * @filled: bitmap of flags using the bits of &enum nl80211_txq_stats to
1825  *	indicate the relevant values in this struct are filled
1826  * @backlog_bytes: total number of bytes currently backlogged
1827  * @backlog_packets: total number of packets currently backlogged
1828  * @flows: number of new flows seen
1829  * @drops: total number of packets dropped
1830  * @ecn_marks: total number of packets marked with ECN CE
1831  * @overlimit: number of drops due to queue space overflow
1832  * @overmemory: number of drops due to memory limit overflow
1833  * @collisions: number of hash collisions
1834  * @tx_bytes: total number of bytes dequeued
1835  * @tx_packets: total number of packets dequeued
1836  * @max_flows: maximum number of flows supported
1837  */
1838 struct cfg80211_txq_stats {
1839 	u32 filled;
1840 	u32 backlog_bytes;
1841 	u32 backlog_packets;
1842 	u32 flows;
1843 	u32 drops;
1844 	u32 ecn_marks;
1845 	u32 overlimit;
1846 	u32 overmemory;
1847 	u32 collisions;
1848 	u32 tx_bytes;
1849 	u32 tx_packets;
1850 	u32 max_flows;
1851 };
1852 
1853 /**
1854  * struct cfg80211_tid_stats - per-TID statistics
1855  * @filled: bitmap of flags using the bits of &enum nl80211_tid_stats to
1856  *	indicate the relevant values in this struct are filled
1857  * @rx_msdu: number of received MSDUs
1858  * @tx_msdu: number of (attempted) transmitted MSDUs
1859  * @tx_msdu_retries: number of retries (not counting the first) for
1860  *	transmitted MSDUs
1861  * @tx_msdu_failed: number of failed transmitted MSDUs
1862  * @txq_stats: TXQ statistics
1863  */
1864 struct cfg80211_tid_stats {
1865 	u32 filled;
1866 	u64 rx_msdu;
1867 	u64 tx_msdu;
1868 	u64 tx_msdu_retries;
1869 	u64 tx_msdu_failed;
1870 	struct cfg80211_txq_stats txq_stats;
1871 };
1872 
1873 #define IEEE80211_MAX_CHAINS	4
1874 
1875 /**
1876  * struct station_info - station information
1877  *
1878  * Station information filled by driver for get_station() and dump_station.
1879  *
1880  * @filled: bitflag of flags using the bits of &enum nl80211_sta_info to
1881  *	indicate the relevant values in this struct for them
1882  * @connected_time: time(in secs) since a station is last connected
1883  * @inactive_time: time since last station activity (tx/rx) in milliseconds
1884  * @assoc_at: bootime (ns) of the last association
1885  * @rx_bytes: bytes (size of MPDUs) received from this station
1886  * @tx_bytes: bytes (size of MPDUs) transmitted to this station
1887  * @llid: mesh local link id
1888  * @plid: mesh peer link id
1889  * @plink_state: mesh peer link state
1890  * @signal: The signal strength, type depends on the wiphy's signal_type.
1891  *	For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_.
1892  * @signal_avg: Average signal strength, type depends on the wiphy's signal_type.
1893  *	For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_.
1894  * @chains: bitmask for filled values in @chain_signal, @chain_signal_avg
1895  * @chain_signal: per-chain signal strength of last received packet in dBm
1896  * @chain_signal_avg: per-chain signal strength average in dBm
1897  * @txrate: current unicast bitrate from this station
1898  * @rxrate: current unicast bitrate to this station
1899  * @rx_packets: packets (MSDUs & MMPDUs) received from this station
1900  * @tx_packets: packets (MSDUs & MMPDUs) transmitted to this station
1901  * @tx_retries: cumulative retry counts (MPDUs)
1902  * @tx_failed: number of failed transmissions (MPDUs) (retries exceeded, no ACK)
1903  * @rx_dropped_misc:  Dropped for un-specified reason.
1904  * @bss_param: current BSS parameters
1905  * @generation: generation number for nl80211 dumps.
1906  *	This number should increase every time the list of stations
1907  *	changes, i.e. when a station is added or removed, so that
1908  *	userspace can tell whether it got a consistent snapshot.
1909  * @assoc_req_ies: IEs from (Re)Association Request.
1910  *	This is used only when in AP mode with drivers that do not use
1911  *	user space MLME/SME implementation. The information is provided for
1912  *	the cfg80211_new_sta() calls to notify user space of the IEs.
1913  * @assoc_req_ies_len: Length of assoc_req_ies buffer in octets.
1914  * @sta_flags: station flags mask & values
1915  * @beacon_loss_count: Number of times beacon loss event has triggered.
1916  * @t_offset: Time offset of the station relative to this host.
1917  * @local_pm: local mesh STA power save mode
1918  * @peer_pm: peer mesh STA power save mode
1919  * @nonpeer_pm: non-peer mesh STA power save mode
1920  * @expected_throughput: expected throughput in kbps (including 802.11 headers)
1921  *	towards this station.
1922  * @rx_beacon: number of beacons received from this peer
1923  * @rx_beacon_signal_avg: signal strength average (in dBm) for beacons received
1924  *	from this peer
1925  * @connected_to_gate: true if mesh STA has a path to mesh gate
1926  * @rx_duration: aggregate PPDU duration(usecs) for all the frames from a peer
1927  * @tx_duration: aggregate PPDU duration(usecs) for all the frames to a peer
1928  * @airtime_weight: current airtime scheduling weight
1929  * @pertid: per-TID statistics, see &struct cfg80211_tid_stats, using the last
1930  *	(IEEE80211_NUM_TIDS) index for MSDUs not encapsulated in QoS-MPDUs.
1931  *	Note that this doesn't use the @filled bit, but is used if non-NULL.
1932  * @ack_signal: signal strength (in dBm) of the last ACK frame.
1933  * @avg_ack_signal: average rssi value of ack packet for the no of msdu's has
1934  *	been sent.
1935  * @rx_mpdu_count: number of MPDUs received from this station
1936  * @fcs_err_count: number of packets (MPDUs) received from this station with
1937  *	an FCS error. This counter should be incremented only when TA of the
1938  *	received packet with an FCS error matches the peer MAC address.
1939  * @airtime_link_metric: mesh airtime link metric.
1940  * @connected_to_as: true if mesh STA has a path to authentication server
1941  * @mlo_params_valid: Indicates @assoc_link_id and @mld_addr fields are filled
1942  *	by driver. Drivers use this only in cfg80211_new_sta() calls when AP
1943  *	MLD's MLME/SME is offload to driver. Drivers won't fill this
1944  *	information in cfg80211_del_sta_sinfo(), get_station() and
1945  *	dump_station() callbacks.
1946  * @assoc_link_id: Indicates MLO link ID of the AP, with which the station
1947  *	completed (re)association. This information filled for both MLO
1948  *	and non-MLO STA connections when the AP affiliated with an MLD.
1949  * @mld_addr: For MLO STA connection, filled with MLD address of the station.
1950  *	For non-MLO STA connection, filled with all zeros.
1951  * @assoc_resp_ies: IEs from (Re)Association Response.
1952  *	This is used only when in AP mode with drivers that do not use user
1953  *	space MLME/SME implementation. The information is provided only for the
1954  *	cfg80211_new_sta() calls to notify user space of the IEs. Drivers won't
1955  *	fill this information in cfg80211_del_sta_sinfo(), get_station() and
1956  *	dump_station() callbacks. User space needs this information to determine
1957  *	the accepted and rejected affiliated links of the connected station.
1958  * @assoc_resp_ies_len: Length of @assoc_resp_ies buffer in octets.
1959  */
1960 struct station_info {
1961 	u64 filled;
1962 	u32 connected_time;
1963 	u32 inactive_time;
1964 	u64 assoc_at;
1965 	u64 rx_bytes;
1966 	u64 tx_bytes;
1967 	u16 llid;
1968 	u16 plid;
1969 	u8 plink_state;
1970 	s8 signal;
1971 	s8 signal_avg;
1972 
1973 	u8 chains;
1974 	s8 chain_signal[IEEE80211_MAX_CHAINS];
1975 	s8 chain_signal_avg[IEEE80211_MAX_CHAINS];
1976 
1977 	struct rate_info txrate;
1978 	struct rate_info rxrate;
1979 	u32 rx_packets;
1980 	u32 tx_packets;
1981 	u32 tx_retries;
1982 	u32 tx_failed;
1983 	u32 rx_dropped_misc;
1984 	struct sta_bss_parameters bss_param;
1985 	struct nl80211_sta_flag_update sta_flags;
1986 
1987 	int generation;
1988 
1989 	const u8 *assoc_req_ies;
1990 	size_t assoc_req_ies_len;
1991 
1992 	u32 beacon_loss_count;
1993 	s64 t_offset;
1994 	enum nl80211_mesh_power_mode local_pm;
1995 	enum nl80211_mesh_power_mode peer_pm;
1996 	enum nl80211_mesh_power_mode nonpeer_pm;
1997 
1998 	u32 expected_throughput;
1999 
2000 	u64 tx_duration;
2001 	u64 rx_duration;
2002 	u64 rx_beacon;
2003 	u8 rx_beacon_signal_avg;
2004 	u8 connected_to_gate;
2005 
2006 	struct cfg80211_tid_stats *pertid;
2007 	s8 ack_signal;
2008 	s8 avg_ack_signal;
2009 
2010 	u16 airtime_weight;
2011 
2012 	u32 rx_mpdu_count;
2013 	u32 fcs_err_count;
2014 
2015 	u32 airtime_link_metric;
2016 
2017 	u8 connected_to_as;
2018 
2019 	bool mlo_params_valid;
2020 	u8 assoc_link_id;
2021 	u8 mld_addr[ETH_ALEN] __aligned(2);
2022 	const u8 *assoc_resp_ies;
2023 	size_t assoc_resp_ies_len;
2024 };
2025 
2026 /**
2027  * struct cfg80211_sar_sub_specs - sub specs limit
2028  * @power: power limitation in 0.25dbm
2029  * @freq_range_index: index the power limitation applies to
2030  */
2031 struct cfg80211_sar_sub_specs {
2032 	s32 power;
2033 	u32 freq_range_index;
2034 };
2035 
2036 /**
2037  * struct cfg80211_sar_specs - sar limit specs
2038  * @type: it's set with power in 0.25dbm or other types
2039  * @num_sub_specs: number of sar sub specs
2040  * @sub_specs: memory to hold the sar sub specs
2041  */
2042 struct cfg80211_sar_specs {
2043 	enum nl80211_sar_type type;
2044 	u32 num_sub_specs;
2045 	struct cfg80211_sar_sub_specs sub_specs[];
2046 };
2047 
2048 
2049 /**
2050  * struct cfg80211_sar_freq_ranges - sar frequency ranges
2051  * @start_freq:  start range edge frequency
2052  * @end_freq:    end range edge frequency
2053  */
2054 struct cfg80211_sar_freq_ranges {
2055 	u32 start_freq;
2056 	u32 end_freq;
2057 };
2058 
2059 /**
2060  * struct cfg80211_sar_capa - sar limit capability
2061  * @type: it's set via power in 0.25dbm or other types
2062  * @num_freq_ranges: number of frequency ranges
2063  * @freq_ranges: memory to hold the freq ranges.
2064  *
2065  * Note: WLAN driver may append new ranges or split an existing
2066  * range to small ones and then append them.
2067  */
2068 struct cfg80211_sar_capa {
2069 	enum nl80211_sar_type type;
2070 	u32 num_freq_ranges;
2071 	const struct cfg80211_sar_freq_ranges *freq_ranges;
2072 };
2073 
2074 #if IS_ENABLED(CONFIG_CFG80211)
2075 /**
2076  * cfg80211_get_station - retrieve information about a given station
2077  * @dev: the device where the station is supposed to be connected to
2078  * @mac_addr: the mac address of the station of interest
2079  * @sinfo: pointer to the structure to fill with the information
2080  *
2081  * Returns 0 on success and sinfo is filled with the available information
2082  * otherwise returns a negative error code and the content of sinfo has to be
2083  * considered undefined.
2084  */
2085 int cfg80211_get_station(struct net_device *dev, const u8 *mac_addr,
2086 			 struct station_info *sinfo);
2087 #else
cfg80211_get_station(struct net_device * dev,const u8 * mac_addr,struct station_info * sinfo)2088 static inline int cfg80211_get_station(struct net_device *dev,
2089 				       const u8 *mac_addr,
2090 				       struct station_info *sinfo)
2091 {
2092 	return -ENOENT;
2093 }
2094 #endif
2095 
2096 /**
2097  * enum monitor_flags - monitor flags
2098  *
2099  * Monitor interface configuration flags. Note that these must be the bits
2100  * according to the nl80211 flags.
2101  *
2102  * @MONITOR_FLAG_CHANGED: set if the flags were changed
2103  * @MONITOR_FLAG_FCSFAIL: pass frames with bad FCS
2104  * @MONITOR_FLAG_PLCPFAIL: pass frames with bad PLCP
2105  * @MONITOR_FLAG_CONTROL: pass control frames
2106  * @MONITOR_FLAG_OTHER_BSS: disable BSSID filtering
2107  * @MONITOR_FLAG_COOK_FRAMES: report frames after processing
2108  * @MONITOR_FLAG_ACTIVE: active monitor, ACKs frames on its MAC address
2109  */
2110 enum monitor_flags {
2111 	MONITOR_FLAG_CHANGED		= 1<<__NL80211_MNTR_FLAG_INVALID,
2112 	MONITOR_FLAG_FCSFAIL		= 1<<NL80211_MNTR_FLAG_FCSFAIL,
2113 	MONITOR_FLAG_PLCPFAIL		= 1<<NL80211_MNTR_FLAG_PLCPFAIL,
2114 	MONITOR_FLAG_CONTROL		= 1<<NL80211_MNTR_FLAG_CONTROL,
2115 	MONITOR_FLAG_OTHER_BSS		= 1<<NL80211_MNTR_FLAG_OTHER_BSS,
2116 	MONITOR_FLAG_COOK_FRAMES	= 1<<NL80211_MNTR_FLAG_COOK_FRAMES,
2117 	MONITOR_FLAG_ACTIVE		= 1<<NL80211_MNTR_FLAG_ACTIVE,
2118 };
2119 
2120 /**
2121  * enum mpath_info_flags -  mesh path information flags
2122  *
2123  * Used by the driver to indicate which info in &struct mpath_info it has filled
2124  * in during get_station() or dump_station().
2125  *
2126  * @MPATH_INFO_FRAME_QLEN: @frame_qlen filled
2127  * @MPATH_INFO_SN: @sn filled
2128  * @MPATH_INFO_METRIC: @metric filled
2129  * @MPATH_INFO_EXPTIME: @exptime filled
2130  * @MPATH_INFO_DISCOVERY_TIMEOUT: @discovery_timeout filled
2131  * @MPATH_INFO_DISCOVERY_RETRIES: @discovery_retries filled
2132  * @MPATH_INFO_FLAGS: @flags filled
2133  * @MPATH_INFO_HOP_COUNT: @hop_count filled
2134  * @MPATH_INFO_PATH_CHANGE: @path_change_count filled
2135  */
2136 enum mpath_info_flags {
2137 	MPATH_INFO_FRAME_QLEN		= BIT(0),
2138 	MPATH_INFO_SN			= BIT(1),
2139 	MPATH_INFO_METRIC		= BIT(2),
2140 	MPATH_INFO_EXPTIME		= BIT(3),
2141 	MPATH_INFO_DISCOVERY_TIMEOUT	= BIT(4),
2142 	MPATH_INFO_DISCOVERY_RETRIES	= BIT(5),
2143 	MPATH_INFO_FLAGS		= BIT(6),
2144 	MPATH_INFO_HOP_COUNT		= BIT(7),
2145 	MPATH_INFO_PATH_CHANGE		= BIT(8),
2146 };
2147 
2148 /**
2149  * struct mpath_info - mesh path information
2150  *
2151  * Mesh path information filled by driver for get_mpath() and dump_mpath().
2152  *
2153  * @filled: bitfield of flags from &enum mpath_info_flags
2154  * @frame_qlen: number of queued frames for this destination
2155  * @sn: target sequence number
2156  * @metric: metric (cost) of this mesh path
2157  * @exptime: expiration time for the mesh path from now, in msecs
2158  * @flags: mesh path flags from &enum mesh_path_flags
2159  * @discovery_timeout: total mesh path discovery timeout, in msecs
2160  * @discovery_retries: mesh path discovery retries
2161  * @generation: generation number for nl80211 dumps.
2162  *	This number should increase every time the list of mesh paths
2163  *	changes, i.e. when a station is added or removed, so that
2164  *	userspace can tell whether it got a consistent snapshot.
2165  * @hop_count: hops to destination
2166  * @path_change_count: total number of path changes to destination
2167  */
2168 struct mpath_info {
2169 	u32 filled;
2170 	u32 frame_qlen;
2171 	u32 sn;
2172 	u32 metric;
2173 	u32 exptime;
2174 	u32 discovery_timeout;
2175 	u8 discovery_retries;
2176 	u8 flags;
2177 	u8 hop_count;
2178 	u32 path_change_count;
2179 
2180 	int generation;
2181 };
2182 
2183 /**
2184  * struct bss_parameters - BSS parameters
2185  *
2186  * Used to change BSS parameters (mainly for AP mode).
2187  *
2188  * @link_id: link_id or -1 for non-MLD
2189  * @use_cts_prot: Whether to use CTS protection
2190  *	(0 = no, 1 = yes, -1 = do not change)
2191  * @use_short_preamble: Whether the use of short preambles is allowed
2192  *	(0 = no, 1 = yes, -1 = do not change)
2193  * @use_short_slot_time: Whether the use of short slot time is allowed
2194  *	(0 = no, 1 = yes, -1 = do not change)
2195  * @basic_rates: basic rates in IEEE 802.11 format
2196  *	(or NULL for no change)
2197  * @basic_rates_len: number of basic rates
2198  * @ap_isolate: do not forward packets between connected stations
2199  *	(0 = no, 1 = yes, -1 = do not change)
2200  * @ht_opmode: HT Operation mode
2201  *	(u16 = opmode, -1 = do not change)
2202  * @p2p_ctwindow: P2P CT Window (-1 = no change)
2203  * @p2p_opp_ps: P2P opportunistic PS (-1 = no change)
2204  */
2205 struct bss_parameters {
2206 	int link_id;
2207 	int use_cts_prot;
2208 	int use_short_preamble;
2209 	int use_short_slot_time;
2210 	const u8 *basic_rates;
2211 	u8 basic_rates_len;
2212 	int ap_isolate;
2213 	int ht_opmode;
2214 	s8 p2p_ctwindow, p2p_opp_ps;
2215 };
2216 
2217 /**
2218  * struct mesh_config - 802.11s mesh configuration
2219  *
2220  * These parameters can be changed while the mesh is active.
2221  *
2222  * @dot11MeshRetryTimeout: the initial retry timeout in millisecond units used
2223  *	by the Mesh Peering Open message
2224  * @dot11MeshConfirmTimeout: the initial retry timeout in millisecond units
2225  *	used by the Mesh Peering Open message
2226  * @dot11MeshHoldingTimeout: the confirm timeout in millisecond units used by
2227  *	the mesh peering management to close a mesh peering
2228  * @dot11MeshMaxPeerLinks: the maximum number of peer links allowed on this
2229  *	mesh interface
2230  * @dot11MeshMaxRetries: the maximum number of peer link open retries that can
2231  *	be sent to establish a new peer link instance in a mesh
2232  * @dot11MeshTTL: the value of TTL field set at a source mesh STA
2233  * @element_ttl: the value of TTL field set at a mesh STA for path selection
2234  *	elements
2235  * @auto_open_plinks: whether we should automatically open peer links when we
2236  *	detect compatible mesh peers
2237  * @dot11MeshNbrOffsetMaxNeighbor: the maximum number of neighbors to
2238  *	synchronize to for 11s default synchronization method
2239  * @dot11MeshHWMPmaxPREQretries: the number of action frames containing a PREQ
2240  *	that an originator mesh STA can send to a particular path target
2241  * @path_refresh_time: how frequently to refresh mesh paths in milliseconds
2242  * @min_discovery_timeout: the minimum length of time to wait until giving up on
2243  *	a path discovery in milliseconds
2244  * @dot11MeshHWMPactivePathTimeout: the time (in TUs) for which mesh STAs
2245  *	receiving a PREQ shall consider the forwarding information from the
2246  *	root to be valid. (TU = time unit)
2247  * @dot11MeshHWMPpreqMinInterval: the minimum interval of time (in TUs) during
2248  *	which a mesh STA can send only one action frame containing a PREQ
2249  *	element
2250  * @dot11MeshHWMPperrMinInterval: the minimum interval of time (in TUs) during
2251  *	which a mesh STA can send only one Action frame containing a PERR
2252  *	element
2253  * @dot11MeshHWMPnetDiameterTraversalTime: the interval of time (in TUs) that
2254  *	it takes for an HWMP information element to propagate across the mesh
2255  * @dot11MeshHWMPRootMode: the configuration of a mesh STA as root mesh STA
2256  * @dot11MeshHWMPRannInterval: the interval of time (in TUs) between root
2257  *	announcements are transmitted
2258  * @dot11MeshGateAnnouncementProtocol: whether to advertise that this mesh
2259  *	station has access to a broader network beyond the MBSS. (This is
2260  *	missnamed in draft 12.0: dot11MeshGateAnnouncementProtocol set to true
2261  *	only means that the station will announce others it's a mesh gate, but
2262  *	not necessarily using the gate announcement protocol. Still keeping the
2263  *	same nomenclature to be in sync with the spec)
2264  * @dot11MeshForwarding: whether the Mesh STA is forwarding or non-forwarding
2265  *	entity (default is TRUE - forwarding entity)
2266  * @rssi_threshold: the threshold for average signal strength of candidate
2267  *	station to establish a peer link
2268  * @ht_opmode: mesh HT protection mode
2269  *
2270  * @dot11MeshHWMPactivePathToRootTimeout: The time (in TUs) for which mesh STAs
2271  *	receiving a proactive PREQ shall consider the forwarding information to
2272  *	the root mesh STA to be valid.
2273  *
2274  * @dot11MeshHWMProotInterval: The interval of time (in TUs) between proactive
2275  *	PREQs are transmitted.
2276  * @dot11MeshHWMPconfirmationInterval: The minimum interval of time (in TUs)
2277  *	during which a mesh STA can send only one Action frame containing
2278  *	a PREQ element for root path confirmation.
2279  * @power_mode: The default mesh power save mode which will be the initial
2280  *	setting for new peer links.
2281  * @dot11MeshAwakeWindowDuration: The duration in TUs the STA will remain awake
2282  *	after transmitting its beacon.
2283  * @plink_timeout: If no tx activity is seen from a STA we've established
2284  *	peering with for longer than this time (in seconds), then remove it
2285  *	from the STA's list of peers.  Default is 30 minutes.
2286  * @dot11MeshConnectedToAuthServer: if set to true then this mesh STA
2287  *	will advertise that it is connected to a authentication server
2288  *	in the mesh formation field.
2289  * @dot11MeshConnectedToMeshGate: if set to true, advertise that this STA is
2290  *      connected to a mesh gate in mesh formation info.  If false, the
2291  *      value in mesh formation is determined by the presence of root paths
2292  *      in the mesh path table
2293  * @dot11MeshNolearn: Try to avoid multi-hop path discovery (e.g. PREQ/PREP
2294  *      for HWMP) if the destination is a direct neighbor. Note that this might
2295  *      not be the optimal decision as a multi-hop route might be better. So
2296  *      if using this setting you will likely also want to disable
2297  *      dot11MeshForwarding and use another mesh routing protocol on top.
2298  */
2299 struct mesh_config {
2300 	u16 dot11MeshRetryTimeout;
2301 	u16 dot11MeshConfirmTimeout;
2302 	u16 dot11MeshHoldingTimeout;
2303 	u16 dot11MeshMaxPeerLinks;
2304 	u8 dot11MeshMaxRetries;
2305 	u8 dot11MeshTTL;
2306 	u8 element_ttl;
2307 	bool auto_open_plinks;
2308 	u32 dot11MeshNbrOffsetMaxNeighbor;
2309 	u8 dot11MeshHWMPmaxPREQretries;
2310 	u32 path_refresh_time;
2311 	u16 min_discovery_timeout;
2312 	u32 dot11MeshHWMPactivePathTimeout;
2313 	u16 dot11MeshHWMPpreqMinInterval;
2314 	u16 dot11MeshHWMPperrMinInterval;
2315 	u16 dot11MeshHWMPnetDiameterTraversalTime;
2316 	u8 dot11MeshHWMPRootMode;
2317 	bool dot11MeshConnectedToMeshGate;
2318 	bool dot11MeshConnectedToAuthServer;
2319 	u16 dot11MeshHWMPRannInterval;
2320 	bool dot11MeshGateAnnouncementProtocol;
2321 	bool dot11MeshForwarding;
2322 	s32 rssi_threshold;
2323 	u16 ht_opmode;
2324 	u32 dot11MeshHWMPactivePathToRootTimeout;
2325 	u16 dot11MeshHWMProotInterval;
2326 	u16 dot11MeshHWMPconfirmationInterval;
2327 	enum nl80211_mesh_power_mode power_mode;
2328 	u16 dot11MeshAwakeWindowDuration;
2329 	u32 plink_timeout;
2330 	bool dot11MeshNolearn;
2331 };
2332 
2333 /**
2334  * struct mesh_setup - 802.11s mesh setup configuration
2335  * @chandef: defines the channel to use
2336  * @mesh_id: the mesh ID
2337  * @mesh_id_len: length of the mesh ID, at least 1 and at most 32 bytes
2338  * @sync_method: which synchronization method to use
2339  * @path_sel_proto: which path selection protocol to use
2340  * @path_metric: which metric to use
2341  * @auth_id: which authentication method this mesh is using
2342  * @ie: vendor information elements (optional)
2343  * @ie_len: length of vendor information elements
2344  * @is_authenticated: this mesh requires authentication
2345  * @is_secure: this mesh uses security
2346  * @user_mpm: userspace handles all MPM functions
2347  * @dtim_period: DTIM period to use
2348  * @beacon_interval: beacon interval to use
2349  * @mcast_rate: multicat rate for Mesh Node [6Mbps is the default for 802.11a]
2350  * @basic_rates: basic rates to use when creating the mesh
2351  * @beacon_rate: bitrate to be used for beacons
2352  * @userspace_handles_dfs: whether user space controls DFS operation, i.e.
2353  *	changes the channel when a radar is detected. This is required
2354  *	to operate on DFS channels.
2355  * @control_port_over_nl80211: TRUE if userspace expects to exchange control
2356  *	port frames over NL80211 instead of the network interface.
2357  *
2358  * These parameters are fixed when the mesh is created.
2359  */
2360 struct mesh_setup {
2361 	struct cfg80211_chan_def chandef;
2362 	const u8 *mesh_id;
2363 	u8 mesh_id_len;
2364 	u8 sync_method;
2365 	u8 path_sel_proto;
2366 	u8 path_metric;
2367 	u8 auth_id;
2368 	const u8 *ie;
2369 	u8 ie_len;
2370 	bool is_authenticated;
2371 	bool is_secure;
2372 	bool user_mpm;
2373 	u8 dtim_period;
2374 	u16 beacon_interval;
2375 	int mcast_rate[NUM_NL80211_BANDS];
2376 	u32 basic_rates;
2377 	struct cfg80211_bitrate_mask beacon_rate;
2378 	bool userspace_handles_dfs;
2379 	bool control_port_over_nl80211;
2380 };
2381 
2382 /**
2383  * struct ocb_setup - 802.11p OCB mode setup configuration
2384  * @chandef: defines the channel to use
2385  *
2386  * These parameters are fixed when connecting to the network
2387  */
2388 struct ocb_setup {
2389 	struct cfg80211_chan_def chandef;
2390 };
2391 
2392 /**
2393  * struct ieee80211_txq_params - TX queue parameters
2394  * @ac: AC identifier
2395  * @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled
2396  * @cwmin: Minimum contention window [a value of the form 2^n-1 in the range
2397  *	1..32767]
2398  * @cwmax: Maximum contention window [a value of the form 2^n-1 in the range
2399  *	1..32767]
2400  * @aifs: Arbitration interframe space [0..255]
2401  * @link_id: link_id or -1 for non-MLD
2402  */
2403 struct ieee80211_txq_params {
2404 	enum nl80211_ac ac;
2405 	u16 txop;
2406 	u16 cwmin;
2407 	u16 cwmax;
2408 	u8 aifs;
2409 	int link_id;
2410 };
2411 
2412 /**
2413  * DOC: Scanning and BSS list handling
2414  *
2415  * The scanning process itself is fairly simple, but cfg80211 offers quite
2416  * a bit of helper functionality. To start a scan, the scan operation will
2417  * be invoked with a scan definition. This scan definition contains the
2418  * channels to scan, and the SSIDs to send probe requests for (including the
2419  * wildcard, if desired). A passive scan is indicated by having no SSIDs to
2420  * probe. Additionally, a scan request may contain extra information elements
2421  * that should be added to the probe request. The IEs are guaranteed to be
2422  * well-formed, and will not exceed the maximum length the driver advertised
2423  * in the wiphy structure.
2424  *
2425  * When scanning finds a BSS, cfg80211 needs to be notified of that, because
2426  * it is responsible for maintaining the BSS list; the driver should not
2427  * maintain a list itself. For this notification, various functions exist.
2428  *
2429  * Since drivers do not maintain a BSS list, there are also a number of
2430  * functions to search for a BSS and obtain information about it from the
2431  * BSS structure cfg80211 maintains. The BSS list is also made available
2432  * to userspace.
2433  */
2434 
2435 /**
2436  * struct cfg80211_ssid - SSID description
2437  * @ssid: the SSID
2438  * @ssid_len: length of the ssid
2439  */
2440 struct cfg80211_ssid {
2441 	u8 ssid[IEEE80211_MAX_SSID_LEN];
2442 	u8 ssid_len;
2443 };
2444 
2445 /**
2446  * struct cfg80211_scan_info - information about completed scan
2447  * @scan_start_tsf: scan start time in terms of the TSF of the BSS that the
2448  *	wireless device that requested the scan is connected to. If this
2449  *	information is not available, this field is left zero.
2450  * @tsf_bssid: the BSSID according to which %scan_start_tsf is set.
2451  * @aborted: set to true if the scan was aborted for any reason,
2452  *	userspace will be notified of that
2453  */
2454 struct cfg80211_scan_info {
2455 	u64 scan_start_tsf;
2456 	u8 tsf_bssid[ETH_ALEN] __aligned(2);
2457 	bool aborted;
2458 };
2459 
2460 /**
2461  * struct cfg80211_scan_6ghz_params - relevant for 6 GHz only
2462  *
2463  * @short_ssid: short ssid to scan for
2464  * @bssid: bssid to scan for
2465  * @channel_idx: idx of the channel in the channel array in the scan request
2466  *	 which the above info relvant to
2467  * @unsolicited_probe: the AP transmits unsolicited probe response every 20 TU
2468  * @short_ssid_valid: @short_ssid is valid and can be used
2469  * @psc_no_listen: when set, and the channel is a PSC channel, no need to wait
2470  *       20 TUs before starting to send probe requests.
2471  * @psd_20: The AP's 20 MHz PSD value.
2472  */
2473 struct cfg80211_scan_6ghz_params {
2474 	u32 short_ssid;
2475 	u32 channel_idx;
2476 	u8 bssid[ETH_ALEN];
2477 	bool unsolicited_probe;
2478 	bool short_ssid_valid;
2479 	bool psc_no_listen;
2480 	s8 psd_20;
2481 };
2482 
2483 /**
2484  * struct cfg80211_scan_request - scan request description
2485  *
2486  * @ssids: SSIDs to scan for (active scan only)
2487  * @n_ssids: number of SSIDs
2488  * @channels: channels to scan on.
2489  * @n_channels: total number of channels to scan
2490  * @scan_width: channel width for scanning
2491  * @ie: optional information element(s) to add into Probe Request or %NULL
2492  * @ie_len: length of ie in octets
2493  * @duration: how long to listen on each channel, in TUs. If
2494  *	%duration_mandatory is not set, this is the maximum dwell time and
2495  *	the actual dwell time may be shorter.
2496  * @duration_mandatory: if set, the scan duration must be as specified by the
2497  *	%duration field.
2498  * @flags: control flags from &enum nl80211_scan_flags
2499  * @rates: bitmap of rates to advertise for each band
2500  * @wiphy: the wiphy this was for
2501  * @scan_start: time (in jiffies) when the scan started
2502  * @wdev: the wireless device to scan for
2503  * @info: (internal) information about completed scan
2504  * @notified: (internal) scan request was notified as done or aborted
2505  * @no_cck: used to send probe requests at non CCK rate in 2GHz band
2506  * @mac_addr: MAC address used with randomisation
2507  * @mac_addr_mask: MAC address mask used with randomisation, bits that
2508  *	are 0 in the mask should be randomised, bits that are 1 should
2509  *	be taken from the @mac_addr
2510  * @scan_6ghz: relevant for split scan request only,
2511  *	true if this is the second scan request
2512  * @n_6ghz_params: number of 6 GHz params
2513  * @scan_6ghz_params: 6 GHz params
2514  * @bssid: BSSID to scan for (most commonly, the wildcard BSSID)
2515  */
2516 struct cfg80211_scan_request {
2517 	struct cfg80211_ssid *ssids;
2518 	int n_ssids;
2519 	u32 n_channels;
2520 	enum nl80211_bss_scan_width scan_width;
2521 	const u8 *ie;
2522 	size_t ie_len;
2523 	u16 duration;
2524 	bool duration_mandatory;
2525 	u32 flags;
2526 
2527 	u32 rates[NUM_NL80211_BANDS];
2528 
2529 	struct wireless_dev *wdev;
2530 
2531 	u8 mac_addr[ETH_ALEN] __aligned(2);
2532 	u8 mac_addr_mask[ETH_ALEN] __aligned(2);
2533 	u8 bssid[ETH_ALEN] __aligned(2);
2534 
2535 	/* internal */
2536 	struct wiphy *wiphy;
2537 	unsigned long scan_start;
2538 	struct cfg80211_scan_info info;
2539 	bool notified;
2540 	bool no_cck;
2541 	bool scan_6ghz;
2542 	u32 n_6ghz_params;
2543 	struct cfg80211_scan_6ghz_params *scan_6ghz_params;
2544 
2545 	/* keep last */
2546 	struct ieee80211_channel *channels[] __counted_by(n_channels);
2547 };
2548 
get_random_mask_addr(u8 * buf,const u8 * addr,const u8 * mask)2549 static inline void get_random_mask_addr(u8 *buf, const u8 *addr, const u8 *mask)
2550 {
2551 	int i;
2552 
2553 	get_random_bytes(buf, ETH_ALEN);
2554 	for (i = 0; i < ETH_ALEN; i++) {
2555 		buf[i] &= ~mask[i];
2556 		buf[i] |= addr[i] & mask[i];
2557 	}
2558 }
2559 
2560 /**
2561  * struct cfg80211_match_set - sets of attributes to match
2562  *
2563  * @ssid: SSID to be matched; may be zero-length in case of BSSID match
2564  *	or no match (RSSI only)
2565  * @bssid: BSSID to be matched; may be all-zero BSSID in case of SSID match
2566  *	or no match (RSSI only)
2567  * @rssi_thold: don't report scan results below this threshold (in s32 dBm)
2568  * @per_band_rssi_thold: Minimum rssi threshold for each band to be applied
2569  *	for filtering out scan results received. Drivers advertize this support
2570  *	of band specific rssi based filtering through the feature capability
2571  *	%NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD. These band
2572  *	specific rssi thresholds take precedence over rssi_thold, if specified.
2573  *	If not specified for any band, it will be assigned with rssi_thold of
2574  *	corresponding matchset.
2575  */
2576 struct cfg80211_match_set {
2577 	struct cfg80211_ssid ssid;
2578 	u8 bssid[ETH_ALEN];
2579 	s32 rssi_thold;
2580 	s32 per_band_rssi_thold[NUM_NL80211_BANDS];
2581 };
2582 
2583 /**
2584  * struct cfg80211_sched_scan_plan - scan plan for scheduled scan
2585  *
2586  * @interval: interval between scheduled scan iterations. In seconds.
2587  * @iterations: number of scan iterations in this scan plan. Zero means
2588  *	infinite loop.
2589  *	The last scan plan will always have this parameter set to zero,
2590  *	all other scan plans will have a finite number of iterations.
2591  */
2592 struct cfg80211_sched_scan_plan {
2593 	u32 interval;
2594 	u32 iterations;
2595 };
2596 
2597 /**
2598  * struct cfg80211_bss_select_adjust - BSS selection with RSSI adjustment.
2599  *
2600  * @band: band of BSS which should match for RSSI level adjustment.
2601  * @delta: value of RSSI level adjustment.
2602  */
2603 struct cfg80211_bss_select_adjust {
2604 	enum nl80211_band band;
2605 	s8 delta;
2606 };
2607 
2608 /**
2609  * struct cfg80211_sched_scan_request - scheduled scan request description
2610  *
2611  * @reqid: identifies this request.
2612  * @ssids: SSIDs to scan for (passed in the probe_reqs in active scans)
2613  * @n_ssids: number of SSIDs
2614  * @n_channels: total number of channels to scan
2615  * @scan_width: channel width for scanning
2616  * @ie: optional information element(s) to add into Probe Request or %NULL
2617  * @ie_len: length of ie in octets
2618  * @flags: control flags from &enum nl80211_scan_flags
2619  * @match_sets: sets of parameters to be matched for a scan result
2620  *	entry to be considered valid and to be passed to the host
2621  *	(others are filtered out).
2622  *	If ommited, all results are passed.
2623  * @n_match_sets: number of match sets
2624  * @report_results: indicates that results were reported for this request
2625  * @wiphy: the wiphy this was for
2626  * @dev: the interface
2627  * @scan_start: start time of the scheduled scan
2628  * @channels: channels to scan
2629  * @min_rssi_thold: for drivers only supporting a single threshold, this
2630  *	contains the minimum over all matchsets
2631  * @mac_addr: MAC address used with randomisation
2632  * @mac_addr_mask: MAC address mask used with randomisation, bits that
2633  *	are 0 in the mask should be randomised, bits that are 1 should
2634  *	be taken from the @mac_addr
2635  * @scan_plans: scan plans to be executed in this scheduled scan. Lowest
2636  *	index must be executed first.
2637  * @n_scan_plans: number of scan plans, at least 1.
2638  * @rcu_head: RCU callback used to free the struct
2639  * @owner_nlportid: netlink portid of owner (if this should is a request
2640  *	owned by a particular socket)
2641  * @nl_owner_dead: netlink owner socket was closed - this request be freed
2642  * @list: for keeping list of requests.
2643  * @delay: delay in seconds to use before starting the first scan
2644  *	cycle.  The driver may ignore this parameter and start
2645  *	immediately (or at any other time), if this feature is not
2646  *	supported.
2647  * @relative_rssi_set: Indicates whether @relative_rssi is set or not.
2648  * @relative_rssi: Relative RSSI threshold in dB to restrict scan result
2649  *	reporting in connected state to cases where a matching BSS is determined
2650  *	to have better or slightly worse RSSI than the current connected BSS.
2651  *	The relative RSSI threshold values are ignored in disconnected state.
2652  * @rssi_adjust: delta dB of RSSI preference to be given to the BSSs that belong
2653  *	to the specified band while deciding whether a better BSS is reported
2654  *	using @relative_rssi. If delta is a negative number, the BSSs that
2655  *	belong to the specified band will be penalized by delta dB in relative
2656  *	comparisions.
2657  */
2658 struct cfg80211_sched_scan_request {
2659 	u64 reqid;
2660 	struct cfg80211_ssid *ssids;
2661 	int n_ssids;
2662 	u32 n_channels;
2663 	enum nl80211_bss_scan_width scan_width;
2664 	const u8 *ie;
2665 	size_t ie_len;
2666 	u32 flags;
2667 	struct cfg80211_match_set *match_sets;
2668 	int n_match_sets;
2669 	s32 min_rssi_thold;
2670 	u32 delay;
2671 	struct cfg80211_sched_scan_plan *scan_plans;
2672 	int n_scan_plans;
2673 
2674 	u8 mac_addr[ETH_ALEN] __aligned(2);
2675 	u8 mac_addr_mask[ETH_ALEN] __aligned(2);
2676 
2677 	bool relative_rssi_set;
2678 	s8 relative_rssi;
2679 	struct cfg80211_bss_select_adjust rssi_adjust;
2680 
2681 	/* internal */
2682 	struct wiphy *wiphy;
2683 	struct net_device *dev;
2684 	unsigned long scan_start;
2685 	bool report_results;
2686 	struct rcu_head rcu_head;
2687 	u32 owner_nlportid;
2688 	bool nl_owner_dead;
2689 	struct list_head list;
2690 
2691 	/* keep last */
2692 	struct ieee80211_channel *channels[];
2693 };
2694 
2695 /**
2696  * enum cfg80211_signal_type - signal type
2697  *
2698  * @CFG80211_SIGNAL_TYPE_NONE: no signal strength information available
2699  * @CFG80211_SIGNAL_TYPE_MBM: signal strength in mBm (100*dBm)
2700  * @CFG80211_SIGNAL_TYPE_UNSPEC: signal strength, increasing from 0 through 100
2701  */
2702 enum cfg80211_signal_type {
2703 	CFG80211_SIGNAL_TYPE_NONE,
2704 	CFG80211_SIGNAL_TYPE_MBM,
2705 	CFG80211_SIGNAL_TYPE_UNSPEC,
2706 };
2707 
2708 /**
2709  * struct cfg80211_inform_bss - BSS inform data
2710  * @chan: channel the frame was received on
2711  * @scan_width: scan width that was used
2712  * @signal: signal strength value, according to the wiphy's
2713  *	signal type
2714  * @boottime_ns: timestamp (CLOCK_BOOTTIME) when the information was
2715  *	received; should match the time when the frame was actually
2716  *	received by the device (not just by the host, in case it was
2717  *	buffered on the device) and be accurate to about 10ms.
2718  *	If the frame isn't buffered, just passing the return value of
2719  *	ktime_get_boottime_ns() is likely appropriate.
2720  * @parent_tsf: the time at the start of reception of the first octet of the
2721  *	timestamp field of the frame. The time is the TSF of the BSS specified
2722  *	by %parent_bssid.
2723  * @parent_bssid: the BSS according to which %parent_tsf is set. This is set to
2724  *	the BSS that requested the scan in which the beacon/probe was received.
2725  * @chains: bitmask for filled values in @chain_signal.
2726  * @chain_signal: per-chain signal strength of last received BSS in dBm.
2727  * @drv_data: Data to be passed through to @inform_bss
2728  */
2729 struct cfg80211_inform_bss {
2730 	struct ieee80211_channel *chan;
2731 	enum nl80211_bss_scan_width scan_width;
2732 	s32 signal;
2733 	u64 boottime_ns;
2734 	u64 parent_tsf;
2735 	u8 parent_bssid[ETH_ALEN] __aligned(2);
2736 	u8 chains;
2737 	s8 chain_signal[IEEE80211_MAX_CHAINS];
2738 
2739 	void *drv_data;
2740 };
2741 
2742 /**
2743  * struct cfg80211_bss_ies - BSS entry IE data
2744  * @tsf: TSF contained in the frame that carried these IEs
2745  * @rcu_head: internal use, for freeing
2746  * @len: length of the IEs
2747  * @from_beacon: these IEs are known to come from a beacon
2748  * @data: IE data
2749  */
2750 struct cfg80211_bss_ies {
2751 	u64 tsf;
2752 	struct rcu_head rcu_head;
2753 	int len;
2754 	bool from_beacon;
2755 	u8 data[];
2756 };
2757 
2758 /**
2759  * struct cfg80211_bss - BSS description
2760  *
2761  * This structure describes a BSS (which may also be a mesh network)
2762  * for use in scan results and similar.
2763  *
2764  * @channel: channel this BSS is on
2765  * @scan_width: width of the control channel
2766  * @bssid: BSSID of the BSS
2767  * @beacon_interval: the beacon interval as from the frame
2768  * @capability: the capability field in host byte order
2769  * @ies: the information elements (Note that there is no guarantee that these
2770  *	are well-formed!); this is a pointer to either the beacon_ies or
2771  *	proberesp_ies depending on whether Probe Response frame has been
2772  *	received. It is always non-%NULL.
2773  * @beacon_ies: the information elements from the last Beacon frame
2774  *	(implementation note: if @hidden_beacon_bss is set this struct doesn't
2775  *	own the beacon_ies, but they're just pointers to the ones from the
2776  *	@hidden_beacon_bss struct)
2777  * @proberesp_ies: the information elements from the last Probe Response frame
2778  * @hidden_beacon_bss: in case this BSS struct represents a probe response from
2779  *	a BSS that hides the SSID in its beacon, this points to the BSS struct
2780  *	that holds the beacon data. @beacon_ies is still valid, of course, and
2781  *	points to the same data as hidden_beacon_bss->beacon_ies in that case.
2782  * @transmitted_bss: pointer to the transmitted BSS, if this is a
2783  *	non-transmitted one (multi-BSSID support)
2784  * @nontrans_list: list of non-transmitted BSS, if this is a transmitted one
2785  *	(multi-BSSID support)
2786  * @signal: signal strength value (type depends on the wiphy's signal_type)
2787  * @chains: bitmask for filled values in @chain_signal.
2788  * @chain_signal: per-chain signal strength of last received BSS in dBm.
2789  * @bssid_index: index in the multiple BSS set
2790  * @max_bssid_indicator: max number of members in the BSS set
2791  * @priv: private area for driver use, has at least wiphy->bss_priv_size bytes
2792  */
2793 struct cfg80211_bss {
2794 	struct ieee80211_channel *channel;
2795 	enum nl80211_bss_scan_width scan_width;
2796 
2797 	const struct cfg80211_bss_ies __rcu *ies;
2798 	const struct cfg80211_bss_ies __rcu *beacon_ies;
2799 	const struct cfg80211_bss_ies __rcu *proberesp_ies;
2800 
2801 	struct cfg80211_bss *hidden_beacon_bss;
2802 	struct cfg80211_bss *transmitted_bss;
2803 	struct list_head nontrans_list;
2804 
2805 	s32 signal;
2806 
2807 	u16 beacon_interval;
2808 	u16 capability;
2809 
2810 	u8 bssid[ETH_ALEN];
2811 	u8 chains;
2812 	s8 chain_signal[IEEE80211_MAX_CHAINS];
2813 
2814 	u8 bssid_index;
2815 	u8 max_bssid_indicator;
2816 
2817 	u8 priv[] __aligned(sizeof(void *));
2818 };
2819 
2820 /**
2821  * ieee80211_bss_get_elem - find element with given ID
2822  * @bss: the bss to search
2823  * @id: the element ID
2824  *
2825  * Note that the return value is an RCU-protected pointer, so
2826  * rcu_read_lock() must be held when calling this function.
2827  * Return: %NULL if not found.
2828  */
2829 const struct element *ieee80211_bss_get_elem(struct cfg80211_bss *bss, u8 id);
2830 
2831 /**
2832  * ieee80211_bss_get_ie - find IE with given ID
2833  * @bss: the bss to search
2834  * @id: the element ID
2835  *
2836  * Note that the return value is an RCU-protected pointer, so
2837  * rcu_read_lock() must be held when calling this function.
2838  * Return: %NULL if not found.
2839  */
ieee80211_bss_get_ie(struct cfg80211_bss * bss,u8 id)2840 static inline const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 id)
2841 {
2842 	return (const void *)ieee80211_bss_get_elem(bss, id);
2843 }
2844 
2845 
2846 /**
2847  * struct cfg80211_auth_request - Authentication request data
2848  *
2849  * This structure provides information needed to complete IEEE 802.11
2850  * authentication.
2851  *
2852  * @bss: The BSS to authenticate with, the callee must obtain a reference
2853  *	to it if it needs to keep it.
2854  * @auth_type: Authentication type (algorithm)
2855  * @ie: Extra IEs to add to Authentication frame or %NULL
2856  * @ie_len: Length of ie buffer in octets
2857  * @key_len: length of WEP key for shared key authentication
2858  * @key_idx: index of WEP key for shared key authentication
2859  * @key: WEP key for shared key authentication
2860  * @auth_data: Fields and elements in Authentication frames. This contains
2861  *	the authentication frame body (non-IE and IE data), excluding the
2862  *	Authentication algorithm number, i.e., starting at the Authentication
2863  *	transaction sequence number field.
2864  * @auth_data_len: Length of auth_data buffer in octets
2865  * @link_id: if >= 0, indicates authentication should be done as an MLD,
2866  *	the interface address is included as the MLD address and the
2867  *	necessary link (with the given link_id) will be created (and
2868  *	given an MLD address) by the driver
2869  * @ap_mld_addr: AP MLD address in case of authentication request with
2870  *	an AP MLD, valid iff @link_id >= 0
2871  */
2872 struct cfg80211_auth_request {
2873 	struct cfg80211_bss *bss;
2874 	const u8 *ie;
2875 	size_t ie_len;
2876 	enum nl80211_auth_type auth_type;
2877 	const u8 *key;
2878 	u8 key_len;
2879 	s8 key_idx;
2880 	const u8 *auth_data;
2881 	size_t auth_data_len;
2882 	s8 link_id;
2883 	const u8 *ap_mld_addr;
2884 };
2885 
2886 /**
2887  * struct cfg80211_assoc_link - per-link information for MLO association
2888  * @bss: the BSS pointer, see also &struct cfg80211_assoc_request::bss;
2889  *	if this is %NULL for a link, that link is not requested
2890  * @elems: extra elements for the per-STA profile for this link
2891  * @elems_len: length of the elements
2892  * @disabled: If set this link should be included during association etc. but it
2893  *	should not be used until enabled by the AP MLD.
2894  */
2895 struct cfg80211_assoc_link {
2896 	struct cfg80211_bss *bss;
2897 	const u8 *elems;
2898 	size_t elems_len;
2899 	bool disabled;
2900 };
2901 
2902 /**
2903  * enum cfg80211_assoc_req_flags - Over-ride default behaviour in association.
2904  *
2905  * @ASSOC_REQ_DISABLE_HT:  Disable HT (802.11n)
2906  * @ASSOC_REQ_DISABLE_VHT:  Disable VHT
2907  * @ASSOC_REQ_USE_RRM: Declare RRM capability in this association
2908  * @CONNECT_REQ_EXTERNAL_AUTH_SUPPORT: User space indicates external
2909  *	authentication capability. Drivers can offload authentication to
2910  *	userspace if this flag is set. Only applicable for cfg80211_connect()
2911  *	request (connect callback).
2912  * @ASSOC_REQ_DISABLE_HE:  Disable HE
2913  * @ASSOC_REQ_DISABLE_EHT:  Disable EHT
2914  * @CONNECT_REQ_MLO_SUPPORT: Userspace indicates support for handling MLD links.
2915  *	Drivers shall disable MLO features for the current association if this
2916  *	flag is not set.
2917  */
2918 enum cfg80211_assoc_req_flags {
2919 	ASSOC_REQ_DISABLE_HT			= BIT(0),
2920 	ASSOC_REQ_DISABLE_VHT			= BIT(1),
2921 	ASSOC_REQ_USE_RRM			= BIT(2),
2922 	CONNECT_REQ_EXTERNAL_AUTH_SUPPORT	= BIT(3),
2923 	ASSOC_REQ_DISABLE_HE			= BIT(4),
2924 	ASSOC_REQ_DISABLE_EHT			= BIT(5),
2925 	CONNECT_REQ_MLO_SUPPORT			= BIT(6),
2926 };
2927 
2928 /**
2929  * struct cfg80211_assoc_request - (Re)Association request data
2930  *
2931  * This structure provides information needed to complete IEEE 802.11
2932  * (re)association.
2933  * @bss: The BSS to associate with. If the call is successful the driver is
2934  *	given a reference that it must give back to cfg80211_send_rx_assoc()
2935  *	or to cfg80211_assoc_timeout(). To ensure proper refcounting, new
2936  *	association requests while already associating must be rejected.
2937  *	This also applies to the @links.bss parameter, which is used instead
2938  *	of this one (it is %NULL) for MLO associations.
2939  * @ie: Extra IEs to add to (Re)Association Request frame or %NULL
2940  * @ie_len: Length of ie buffer in octets
2941  * @use_mfp: Use management frame protection (IEEE 802.11w) in this association
2942  * @crypto: crypto settings
2943  * @prev_bssid: previous BSSID, if not %NULL use reassociate frame. This is used
2944  *	to indicate a request to reassociate within the ESS instead of a request
2945  *	do the initial association with the ESS. When included, this is set to
2946  *	the BSSID of the current association, i.e., to the value that is
2947  *	included in the Current AP address field of the Reassociation Request
2948  *	frame.
2949  * @flags:  See &enum cfg80211_assoc_req_flags
2950  * @ht_capa:  HT Capabilities over-rides.  Values set in ht_capa_mask
2951  *	will be used in ht_capa.  Un-supported values will be ignored.
2952  * @ht_capa_mask:  The bits of ht_capa which are to be used.
2953  * @vht_capa: VHT capability override
2954  * @vht_capa_mask: VHT capability mask indicating which fields to use
2955  * @fils_kek: FILS KEK for protecting (Re)Association Request/Response frame or
2956  *	%NULL if FILS is not used.
2957  * @fils_kek_len: Length of fils_kek in octets
2958  * @fils_nonces: FILS nonces (part of AAD) for protecting (Re)Association
2959  *	Request/Response frame or %NULL if FILS is not used. This field starts
2960  *	with 16 octets of STA Nonce followed by 16 octets of AP Nonce.
2961  * @s1g_capa: S1G capability override
2962  * @s1g_capa_mask: S1G capability override mask
2963  * @links: per-link information for MLO connections
2964  * @link_id: >= 0 for MLO connections, where links are given, and indicates
2965  *	the link on which the association request should be sent
2966  * @ap_mld_addr: AP MLD address in case of MLO association request,
2967  *	valid iff @link_id >= 0
2968  */
2969 struct cfg80211_assoc_request {
2970 	struct cfg80211_bss *bss;
2971 	const u8 *ie, *prev_bssid;
2972 	size_t ie_len;
2973 	struct cfg80211_crypto_settings crypto;
2974 	bool use_mfp;
2975 	u32 flags;
2976 	struct ieee80211_ht_cap ht_capa;
2977 	struct ieee80211_ht_cap ht_capa_mask;
2978 	struct ieee80211_vht_cap vht_capa, vht_capa_mask;
2979 	const u8 *fils_kek;
2980 	size_t fils_kek_len;
2981 	const u8 *fils_nonces;
2982 	struct ieee80211_s1g_cap s1g_capa, s1g_capa_mask;
2983 	struct cfg80211_assoc_link links[IEEE80211_MLD_MAX_NUM_LINKS];
2984 	const u8 *ap_mld_addr;
2985 	s8 link_id;
2986 };
2987 
2988 /**
2989  * struct cfg80211_deauth_request - Deauthentication request data
2990  *
2991  * This structure provides information needed to complete IEEE 802.11
2992  * deauthentication.
2993  *
2994  * @bssid: the BSSID or AP MLD address to deauthenticate from
2995  * @ie: Extra IEs to add to Deauthentication frame or %NULL
2996  * @ie_len: Length of ie buffer in octets
2997  * @reason_code: The reason code for the deauthentication
2998  * @local_state_change: if set, change local state only and
2999  *	do not set a deauth frame
3000  */
3001 struct cfg80211_deauth_request {
3002 	const u8 *bssid;
3003 	const u8 *ie;
3004 	size_t ie_len;
3005 	u16 reason_code;
3006 	bool local_state_change;
3007 };
3008 
3009 /**
3010  * struct cfg80211_disassoc_request - Disassociation request data
3011  *
3012  * This structure provides information needed to complete IEEE 802.11
3013  * disassociation.
3014  *
3015  * @ap_addr: the BSSID or AP MLD address to disassociate from
3016  * @ie: Extra IEs to add to Disassociation frame or %NULL
3017  * @ie_len: Length of ie buffer in octets
3018  * @reason_code: The reason code for the disassociation
3019  * @local_state_change: This is a request for a local state only, i.e., no
3020  *	Disassociation frame is to be transmitted.
3021  */
3022 struct cfg80211_disassoc_request {
3023 	const u8 *ap_addr;
3024 	const u8 *ie;
3025 	size_t ie_len;
3026 	u16 reason_code;
3027 	bool local_state_change;
3028 };
3029 
3030 /**
3031  * struct cfg80211_ibss_params - IBSS parameters
3032  *
3033  * This structure defines the IBSS parameters for the join_ibss()
3034  * method.
3035  *
3036  * @ssid: The SSID, will always be non-null.
3037  * @ssid_len: The length of the SSID, will always be non-zero.
3038  * @bssid: Fixed BSSID requested, maybe be %NULL, if set do not
3039  *	search for IBSSs with a different BSSID.
3040  * @chandef: defines the channel to use if no other IBSS to join can be found
3041  * @channel_fixed: The channel should be fixed -- do not search for
3042  *	IBSSs to join on other channels.
3043  * @ie: information element(s) to include in the beacon
3044  * @ie_len: length of that
3045  * @beacon_interval: beacon interval to use
3046  * @privacy: this is a protected network, keys will be configured
3047  *	after joining
3048  * @control_port: whether user space controls IEEE 802.1X port, i.e.,
3049  *	sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is
3050  *	required to assume that the port is unauthorized until authorized by
3051  *	user space. Otherwise, port is marked authorized by default.
3052  * @control_port_over_nl80211: TRUE if userspace expects to exchange control
3053  *	port frames over NL80211 instead of the network interface.
3054  * @userspace_handles_dfs: whether user space controls DFS operation, i.e.
3055  *	changes the channel when a radar is detected. This is required
3056  *	to operate on DFS channels.
3057  * @basic_rates: bitmap of basic rates to use when creating the IBSS
3058  * @mcast_rate: per-band multicast rate index + 1 (0: disabled)
3059  * @ht_capa:  HT Capabilities over-rides.  Values set in ht_capa_mask
3060  *	will be used in ht_capa.  Un-supported values will be ignored.
3061  * @ht_capa_mask:  The bits of ht_capa which are to be used.
3062  * @wep_keys: static WEP keys, if not NULL points to an array of
3063  *	CFG80211_MAX_WEP_KEYS WEP keys
3064  * @wep_tx_key: key index (0..3) of the default TX static WEP key
3065  */
3066 struct cfg80211_ibss_params {
3067 	const u8 *ssid;
3068 	const u8 *bssid;
3069 	struct cfg80211_chan_def chandef;
3070 	const u8 *ie;
3071 	u8 ssid_len, ie_len;
3072 	u16 beacon_interval;
3073 	u32 basic_rates;
3074 	bool channel_fixed;
3075 	bool privacy;
3076 	bool control_port;
3077 	bool control_port_over_nl80211;
3078 	bool userspace_handles_dfs;
3079 	int mcast_rate[NUM_NL80211_BANDS];
3080 	struct ieee80211_ht_cap ht_capa;
3081 	struct ieee80211_ht_cap ht_capa_mask;
3082 	struct key_params *wep_keys;
3083 	int wep_tx_key;
3084 };
3085 
3086 /**
3087  * struct cfg80211_bss_selection - connection parameters for BSS selection.
3088  *
3089  * @behaviour: requested BSS selection behaviour.
3090  * @param: parameters for requestion behaviour.
3091  * @band_pref: preferred band for %NL80211_BSS_SELECT_ATTR_BAND_PREF.
3092  * @adjust: parameters for %NL80211_BSS_SELECT_ATTR_RSSI_ADJUST.
3093  */
3094 struct cfg80211_bss_selection {
3095 	enum nl80211_bss_select_attr behaviour;
3096 	union {
3097 		enum nl80211_band band_pref;
3098 		struct cfg80211_bss_select_adjust adjust;
3099 	} param;
3100 };
3101 
3102 /**
3103  * struct cfg80211_connect_params - Connection parameters
3104  *
3105  * This structure provides information needed to complete IEEE 802.11
3106  * authentication and association.
3107  *
3108  * @channel: The channel to use or %NULL if not specified (auto-select based
3109  *	on scan results)
3110  * @channel_hint: The channel of the recommended BSS for initial connection or
3111  *	%NULL if not specified
3112  * @bssid: The AP BSSID or %NULL if not specified (auto-select based on scan
3113  *	results)
3114  * @bssid_hint: The recommended AP BSSID for initial connection to the BSS or
3115  *	%NULL if not specified. Unlike the @bssid parameter, the driver is
3116  *	allowed to ignore this @bssid_hint if it has knowledge of a better BSS
3117  *	to use.
3118  * @ssid: SSID
3119  * @ssid_len: Length of ssid in octets
3120  * @auth_type: Authentication type (algorithm)
3121  * @ie: IEs for association request
3122  * @ie_len: Length of assoc_ie in octets
3123  * @privacy: indicates whether privacy-enabled APs should be used
3124  * @mfp: indicate whether management frame protection is used
3125  * @crypto: crypto settings
3126  * @key_len: length of WEP key for shared key authentication
3127  * @key_idx: index of WEP key for shared key authentication
3128  * @key: WEP key for shared key authentication
3129  * @flags:  See &enum cfg80211_assoc_req_flags
3130  * @bg_scan_period:  Background scan period in seconds
3131  *	or -1 to indicate that default value is to be used.
3132  * @ht_capa:  HT Capabilities over-rides.  Values set in ht_capa_mask
3133  *	will be used in ht_capa.  Un-supported values will be ignored.
3134  * @ht_capa_mask:  The bits of ht_capa which are to be used.
3135  * @vht_capa:  VHT Capability overrides
3136  * @vht_capa_mask: The bits of vht_capa which are to be used.
3137  * @pbss: if set, connect to a PCP instead of AP. Valid for DMG
3138  *	networks.
3139  * @bss_select: criteria to be used for BSS selection.
3140  * @prev_bssid: previous BSSID, if not %NULL use reassociate frame. This is used
3141  *	to indicate a request to reassociate within the ESS instead of a request
3142  *	do the initial association with the ESS. When included, this is set to
3143  *	the BSSID of the current association, i.e., to the value that is
3144  *	included in the Current AP address field of the Reassociation Request
3145  *	frame.
3146  * @fils_erp_username: EAP re-authentication protocol (ERP) username part of the
3147  *	NAI or %NULL if not specified. This is used to construct FILS wrapped
3148  *	data IE.
3149  * @fils_erp_username_len: Length of @fils_erp_username in octets.
3150  * @fils_erp_realm: EAP re-authentication protocol (ERP) realm part of NAI or
3151  *	%NULL if not specified. This specifies the domain name of ER server and
3152  *	is used to construct FILS wrapped data IE.
3153  * @fils_erp_realm_len: Length of @fils_erp_realm in octets.
3154  * @fils_erp_next_seq_num: The next sequence number to use in the FILS ERP
3155  *	messages. This is also used to construct FILS wrapped data IE.
3156  * @fils_erp_rrk: ERP re-authentication Root Key (rRK) used to derive additional
3157  *	keys in FILS or %NULL if not specified.
3158  * @fils_erp_rrk_len: Length of @fils_erp_rrk in octets.
3159  * @want_1x: indicates user-space supports and wants to use 802.1X driver
3160  *	offload of 4-way handshake.
3161  * @edmg: define the EDMG channels.
3162  *	This may specify multiple channels and bonding options for the driver
3163  *	to choose from, based on BSS configuration.
3164  */
3165 struct cfg80211_connect_params {
3166 	struct ieee80211_channel *channel;
3167 	struct ieee80211_channel *channel_hint;
3168 	const u8 *bssid;
3169 	const u8 *bssid_hint;
3170 	const u8 *ssid;
3171 	size_t ssid_len;
3172 	enum nl80211_auth_type auth_type;
3173 	const u8 *ie;
3174 	size_t ie_len;
3175 	bool privacy;
3176 	enum nl80211_mfp mfp;
3177 	struct cfg80211_crypto_settings crypto;
3178 	const u8 *key;
3179 	u8 key_len, key_idx;
3180 	u32 flags;
3181 	int bg_scan_period;
3182 	struct ieee80211_ht_cap ht_capa;
3183 	struct ieee80211_ht_cap ht_capa_mask;
3184 	struct ieee80211_vht_cap vht_capa;
3185 	struct ieee80211_vht_cap vht_capa_mask;
3186 	bool pbss;
3187 	struct cfg80211_bss_selection bss_select;
3188 	const u8 *prev_bssid;
3189 	const u8 *fils_erp_username;
3190 	size_t fils_erp_username_len;
3191 	const u8 *fils_erp_realm;
3192 	size_t fils_erp_realm_len;
3193 	u16 fils_erp_next_seq_num;
3194 	const u8 *fils_erp_rrk;
3195 	size_t fils_erp_rrk_len;
3196 	bool want_1x;
3197 	struct ieee80211_edmg edmg;
3198 };
3199 
3200 /**
3201  * enum cfg80211_connect_params_changed - Connection parameters being updated
3202  *
3203  * This enum provides information of all connect parameters that
3204  * have to be updated as part of update_connect_params() call.
3205  *
3206  * @UPDATE_ASSOC_IES: Indicates whether association request IEs are updated
3207  * @UPDATE_FILS_ERP_INFO: Indicates that FILS connection parameters (realm,
3208  *	username, erp sequence number and rrk) are updated
3209  * @UPDATE_AUTH_TYPE: Indicates that authentication type is updated
3210  */
3211 enum cfg80211_connect_params_changed {
3212 	UPDATE_ASSOC_IES		= BIT(0),
3213 	UPDATE_FILS_ERP_INFO		= BIT(1),
3214 	UPDATE_AUTH_TYPE		= BIT(2),
3215 };
3216 
3217 /**
3218  * enum wiphy_params_flags - set_wiphy_params bitfield values
3219  * @WIPHY_PARAM_RETRY_SHORT: wiphy->retry_short has changed
3220  * @WIPHY_PARAM_RETRY_LONG: wiphy->retry_long has changed
3221  * @WIPHY_PARAM_FRAG_THRESHOLD: wiphy->frag_threshold has changed
3222  * @WIPHY_PARAM_RTS_THRESHOLD: wiphy->rts_threshold has changed
3223  * @WIPHY_PARAM_COVERAGE_CLASS: coverage class changed
3224  * @WIPHY_PARAM_DYN_ACK: dynack has been enabled
3225  * @WIPHY_PARAM_TXQ_LIMIT: TXQ packet limit has been changed
3226  * @WIPHY_PARAM_TXQ_MEMORY_LIMIT: TXQ memory limit has been changed
3227  * @WIPHY_PARAM_TXQ_QUANTUM: TXQ scheduler quantum
3228  */
3229 enum wiphy_params_flags {
3230 	WIPHY_PARAM_RETRY_SHORT		= 1 << 0,
3231 	WIPHY_PARAM_RETRY_LONG		= 1 << 1,
3232 	WIPHY_PARAM_FRAG_THRESHOLD	= 1 << 2,
3233 	WIPHY_PARAM_RTS_THRESHOLD	= 1 << 3,
3234 	WIPHY_PARAM_COVERAGE_CLASS	= 1 << 4,
3235 	WIPHY_PARAM_DYN_ACK		= 1 << 5,
3236 	WIPHY_PARAM_TXQ_LIMIT		= 1 << 6,
3237 	WIPHY_PARAM_TXQ_MEMORY_LIMIT	= 1 << 7,
3238 	WIPHY_PARAM_TXQ_QUANTUM		= 1 << 8,
3239 };
3240 
3241 #define IEEE80211_DEFAULT_AIRTIME_WEIGHT	256
3242 
3243 /* The per TXQ device queue limit in airtime */
3244 #define IEEE80211_DEFAULT_AQL_TXQ_LIMIT_L	5000
3245 #define IEEE80211_DEFAULT_AQL_TXQ_LIMIT_H	12000
3246 
3247 /* The per interface airtime threshold to switch to lower queue limit */
3248 #define IEEE80211_AQL_THRESHOLD			24000
3249 
3250 /**
3251  * struct cfg80211_pmksa - PMK Security Association
3252  *
3253  * This structure is passed to the set/del_pmksa() method for PMKSA
3254  * caching.
3255  *
3256  * @bssid: The AP's BSSID (may be %NULL).
3257  * @pmkid: The identifier to refer a PMKSA.
3258  * @pmk: The PMK for the PMKSA identified by @pmkid. This is used for key
3259  *	derivation by a FILS STA. Otherwise, %NULL.
3260  * @pmk_len: Length of the @pmk. The length of @pmk can differ depending on
3261  *	the hash algorithm used to generate this.
3262  * @ssid: SSID to specify the ESS within which a PMKSA is valid when using FILS
3263  *	cache identifier (may be %NULL).
3264  * @ssid_len: Length of the @ssid in octets.
3265  * @cache_id: 2-octet cache identifier advertized by a FILS AP identifying the
3266  *	scope of PMKSA. This is valid only if @ssid_len is non-zero (may be
3267  *	%NULL).
3268  * @pmk_lifetime: Maximum lifetime for PMKSA in seconds
3269  *	(dot11RSNAConfigPMKLifetime) or 0 if not specified.
3270  *	The configured PMKSA must not be used for PMKSA caching after
3271  *	expiration and any keys derived from this PMK become invalid on
3272  *	expiration, i.e., the current association must be dropped if the PMK
3273  *	used for it expires.
3274  * @pmk_reauth_threshold: Threshold time for reauthentication (percentage of
3275  *	PMK lifetime, dot11RSNAConfigPMKReauthThreshold) or 0 if not specified.
3276  *	Drivers are expected to trigger a full authentication instead of using
3277  *	this PMKSA for caching when reassociating to a new BSS after this
3278  *	threshold to generate a new PMK before the current one expires.
3279  */
3280 struct cfg80211_pmksa {
3281 	const u8 *bssid;
3282 	const u8 *pmkid;
3283 	const u8 *pmk;
3284 	size_t pmk_len;
3285 	const u8 *ssid;
3286 	size_t ssid_len;
3287 	const u8 *cache_id;
3288 	u32 pmk_lifetime;
3289 	u8 pmk_reauth_threshold;
3290 };
3291 
3292 /**
3293  * struct cfg80211_pkt_pattern - packet pattern
3294  * @mask: bitmask where to match pattern and where to ignore bytes,
3295  *	one bit per byte, in same format as nl80211
3296  * @pattern: bytes to match where bitmask is 1
3297  * @pattern_len: length of pattern (in bytes)
3298  * @pkt_offset: packet offset (in bytes)
3299  *
3300  * Internal note: @mask and @pattern are allocated in one chunk of
3301  * memory, free @mask only!
3302  */
3303 struct cfg80211_pkt_pattern {
3304 	const u8 *mask, *pattern;
3305 	int pattern_len;
3306 	int pkt_offset;
3307 };
3308 
3309 /**
3310  * struct cfg80211_wowlan_tcp - TCP connection parameters
3311  *
3312  * @sock: (internal) socket for source port allocation
3313  * @src: source IP address
3314  * @dst: destination IP address
3315  * @dst_mac: destination MAC address
3316  * @src_port: source port
3317  * @dst_port: destination port
3318  * @payload_len: data payload length
3319  * @payload: data payload buffer
3320  * @payload_seq: payload sequence stamping configuration
3321  * @data_interval: interval at which to send data packets
3322  * @wake_len: wakeup payload match length
3323  * @wake_data: wakeup payload match data
3324  * @wake_mask: wakeup payload match mask
3325  * @tokens_size: length of the tokens buffer
3326  * @payload_tok: payload token usage configuration
3327  */
3328 struct cfg80211_wowlan_tcp {
3329 	struct socket *sock;
3330 	__be32 src, dst;
3331 	u16 src_port, dst_port;
3332 	u8 dst_mac[ETH_ALEN];
3333 	int payload_len;
3334 	const u8 *payload;
3335 	struct nl80211_wowlan_tcp_data_seq payload_seq;
3336 	u32 data_interval;
3337 	u32 wake_len;
3338 	const u8 *wake_data, *wake_mask;
3339 	u32 tokens_size;
3340 	/* must be last, variable member */
3341 	struct nl80211_wowlan_tcp_data_token payload_tok;
3342 };
3343 
3344 /**
3345  * struct cfg80211_wowlan - Wake on Wireless-LAN support info
3346  *
3347  * This structure defines the enabled WoWLAN triggers for the device.
3348  * @any: wake up on any activity -- special trigger if device continues
3349  *	operating as normal during suspend
3350  * @disconnect: wake up if getting disconnected
3351  * @magic_pkt: wake up on receiving magic packet
3352  * @patterns: wake up on receiving packet matching a pattern
3353  * @n_patterns: number of patterns
3354  * @gtk_rekey_failure: wake up on GTK rekey failure
3355  * @eap_identity_req: wake up on EAP identity request packet
3356  * @four_way_handshake: wake up on 4-way handshake
3357  * @rfkill_release: wake up when rfkill is released
3358  * @tcp: TCP connection establishment/wakeup parameters, see nl80211.h.
3359  *	NULL if not configured.
3360  * @nd_config: configuration for the scan to be used for net detect wake.
3361  */
3362 struct cfg80211_wowlan {
3363 	bool any, disconnect, magic_pkt, gtk_rekey_failure,
3364 	     eap_identity_req, four_way_handshake,
3365 	     rfkill_release;
3366 	struct cfg80211_pkt_pattern *patterns;
3367 	struct cfg80211_wowlan_tcp *tcp;
3368 	int n_patterns;
3369 	struct cfg80211_sched_scan_request *nd_config;
3370 };
3371 
3372 /**
3373  * struct cfg80211_coalesce_rules - Coalesce rule parameters
3374  *
3375  * This structure defines coalesce rule for the device.
3376  * @delay: maximum coalescing delay in msecs.
3377  * @condition: condition for packet coalescence.
3378  *	see &enum nl80211_coalesce_condition.
3379  * @patterns: array of packet patterns
3380  * @n_patterns: number of patterns
3381  */
3382 struct cfg80211_coalesce_rules {
3383 	int delay;
3384 	enum nl80211_coalesce_condition condition;
3385 	struct cfg80211_pkt_pattern *patterns;
3386 	int n_patterns;
3387 };
3388 
3389 /**
3390  * struct cfg80211_coalesce - Packet coalescing settings
3391  *
3392  * This structure defines coalescing settings.
3393  * @rules: array of coalesce rules
3394  * @n_rules: number of rules
3395  */
3396 struct cfg80211_coalesce {
3397 	struct cfg80211_coalesce_rules *rules;
3398 	int n_rules;
3399 };
3400 
3401 /**
3402  * struct cfg80211_wowlan_nd_match - information about the match
3403  *
3404  * @ssid: SSID of the match that triggered the wake up
3405  * @n_channels: Number of channels where the match occurred.  This
3406  *	value may be zero if the driver can't report the channels.
3407  * @channels: center frequencies of the channels where a match
3408  *	occurred (in MHz)
3409  */
3410 struct cfg80211_wowlan_nd_match {
3411 	struct cfg80211_ssid ssid;
3412 	int n_channels;
3413 	u32 channels[];
3414 };
3415 
3416 /**
3417  * struct cfg80211_wowlan_nd_info - net detect wake up information
3418  *
3419  * @n_matches: Number of match information instances provided in
3420  *	@matches.  This value may be zero if the driver can't provide
3421  *	match information.
3422  * @matches: Array of pointers to matches containing information about
3423  *	the matches that triggered the wake up.
3424  */
3425 struct cfg80211_wowlan_nd_info {
3426 	int n_matches;
3427 	struct cfg80211_wowlan_nd_match *matches[];
3428 };
3429 
3430 /**
3431  * struct cfg80211_wowlan_wakeup - wakeup report
3432  * @disconnect: woke up by getting disconnected
3433  * @magic_pkt: woke up by receiving magic packet
3434  * @gtk_rekey_failure: woke up by GTK rekey failure
3435  * @eap_identity_req: woke up by EAP identity request packet
3436  * @four_way_handshake: woke up by 4-way handshake
3437  * @rfkill_release: woke up by rfkill being released
3438  * @pattern_idx: pattern that caused wakeup, -1 if not due to pattern
3439  * @packet_present_len: copied wakeup packet data
3440  * @packet_len: original wakeup packet length
3441  * @packet: The packet causing the wakeup, if any.
3442  * @packet_80211:  For pattern match, magic packet and other data
3443  *	frame triggers an 802.3 frame should be reported, for
3444  *	disconnect due to deauth 802.11 frame. This indicates which
3445  *	it is.
3446  * @tcp_match: TCP wakeup packet received
3447  * @tcp_connlost: TCP connection lost or failed to establish
3448  * @tcp_nomoretokens: TCP data ran out of tokens
3449  * @net_detect: if not %NULL, woke up because of net detect
3450  */
3451 struct cfg80211_wowlan_wakeup {
3452 	bool disconnect, magic_pkt, gtk_rekey_failure,
3453 	     eap_identity_req, four_way_handshake,
3454 	     rfkill_release, packet_80211,
3455 	     tcp_match, tcp_connlost, tcp_nomoretokens;
3456 	s32 pattern_idx;
3457 	u32 packet_present_len, packet_len;
3458 	const void *packet;
3459 	struct cfg80211_wowlan_nd_info *net_detect;
3460 };
3461 
3462 /**
3463  * struct cfg80211_gtk_rekey_data - rekey data
3464  * @kek: key encryption key (@kek_len bytes)
3465  * @kck: key confirmation key (@kck_len bytes)
3466  * @replay_ctr: replay counter (NL80211_REPLAY_CTR_LEN bytes)
3467  * @kek_len: length of kek
3468  * @kck_len: length of kck
3469  * @akm: akm (oui, id)
3470  */
3471 struct cfg80211_gtk_rekey_data {
3472 	const u8 *kek, *kck, *replay_ctr;
3473 	u32 akm;
3474 	u8 kek_len, kck_len;
3475 };
3476 
3477 /**
3478  * struct cfg80211_update_ft_ies_params - FT IE Information
3479  *
3480  * This structure provides information needed to update the fast transition IE
3481  *
3482  * @md: The Mobility Domain ID, 2 Octet value
3483  * @ie: Fast Transition IEs
3484  * @ie_len: Length of ft_ie in octets
3485  */
3486 struct cfg80211_update_ft_ies_params {
3487 	u16 md;
3488 	const u8 *ie;
3489 	size_t ie_len;
3490 };
3491 
3492 /**
3493  * struct cfg80211_mgmt_tx_params - mgmt tx parameters
3494  *
3495  * This structure provides information needed to transmit a mgmt frame
3496  *
3497  * @chan: channel to use
3498  * @offchan: indicates wether off channel operation is required
3499  * @wait: duration for ROC
3500  * @buf: buffer to transmit
3501  * @len: buffer length
3502  * @no_cck: don't use cck rates for this frame
3503  * @dont_wait_for_ack: tells the low level not to wait for an ack
3504  * @n_csa_offsets: length of csa_offsets array
3505  * @csa_offsets: array of all the csa offsets in the frame
3506  * @link_id: for MLO, the link ID to transmit on, -1 if not given; note
3507  *	that the link ID isn't validated (much), it's in range but the
3508  *	link might not exist (or be used by the receiver STA)
3509  */
3510 struct cfg80211_mgmt_tx_params {
3511 	struct ieee80211_channel *chan;
3512 	bool offchan;
3513 	unsigned int wait;
3514 	const u8 *buf;
3515 	size_t len;
3516 	bool no_cck;
3517 	bool dont_wait_for_ack;
3518 	int n_csa_offsets;
3519 	const u16 *csa_offsets;
3520 	int link_id;
3521 };
3522 
3523 /**
3524  * struct cfg80211_dscp_exception - DSCP exception
3525  *
3526  * @dscp: DSCP value that does not adhere to the user priority range definition
3527  * @up: user priority value to which the corresponding DSCP value belongs
3528  */
3529 struct cfg80211_dscp_exception {
3530 	u8 dscp;
3531 	u8 up;
3532 };
3533 
3534 /**
3535  * struct cfg80211_dscp_range - DSCP range definition for user priority
3536  *
3537  * @low: lowest DSCP value of this user priority range, inclusive
3538  * @high: highest DSCP value of this user priority range, inclusive
3539  */
3540 struct cfg80211_dscp_range {
3541 	u8 low;
3542 	u8 high;
3543 };
3544 
3545 /* QoS Map Set element length defined in IEEE Std 802.11-2012, 8.4.2.97 */
3546 #define IEEE80211_QOS_MAP_MAX_EX	21
3547 #define IEEE80211_QOS_MAP_LEN_MIN	16
3548 #define IEEE80211_QOS_MAP_LEN_MAX \
3549 	(IEEE80211_QOS_MAP_LEN_MIN + 2 * IEEE80211_QOS_MAP_MAX_EX)
3550 
3551 /**
3552  * struct cfg80211_qos_map - QoS Map Information
3553  *
3554  * This struct defines the Interworking QoS map setting for DSCP values
3555  *
3556  * @num_des: number of DSCP exceptions (0..21)
3557  * @dscp_exception: optionally up to maximum of 21 DSCP exceptions from
3558  *	the user priority DSCP range definition
3559  * @up: DSCP range definition for a particular user priority
3560  */
3561 struct cfg80211_qos_map {
3562 	u8 num_des;
3563 	struct cfg80211_dscp_exception dscp_exception[IEEE80211_QOS_MAP_MAX_EX];
3564 	struct cfg80211_dscp_range up[8];
3565 };
3566 
3567 /**
3568  * struct cfg80211_nan_conf - NAN configuration
3569  *
3570  * This struct defines NAN configuration parameters
3571  *
3572  * @master_pref: master preference (1 - 255)
3573  * @bands: operating bands, a bitmap of &enum nl80211_band values.
3574  *	For instance, for NL80211_BAND_2GHZ, bit 0 would be set
3575  *	(i.e. BIT(NL80211_BAND_2GHZ)).
3576  */
3577 struct cfg80211_nan_conf {
3578 	u8 master_pref;
3579 	u8 bands;
3580 };
3581 
3582 /**
3583  * enum cfg80211_nan_conf_changes - indicates changed fields in NAN
3584  * configuration
3585  *
3586  * @CFG80211_NAN_CONF_CHANGED_PREF: master preference
3587  * @CFG80211_NAN_CONF_CHANGED_BANDS: operating bands
3588  */
3589 enum cfg80211_nan_conf_changes {
3590 	CFG80211_NAN_CONF_CHANGED_PREF = BIT(0),
3591 	CFG80211_NAN_CONF_CHANGED_BANDS = BIT(1),
3592 };
3593 
3594 /**
3595  * struct cfg80211_nan_func_filter - a NAN function Rx / Tx filter
3596  *
3597  * @filter: the content of the filter
3598  * @len: the length of the filter
3599  */
3600 struct cfg80211_nan_func_filter {
3601 	const u8 *filter;
3602 	u8 len;
3603 };
3604 
3605 /**
3606  * struct cfg80211_nan_func - a NAN function
3607  *
3608  * @type: &enum nl80211_nan_function_type
3609  * @service_id: the service ID of the function
3610  * @publish_type: &nl80211_nan_publish_type
3611  * @close_range: if true, the range should be limited. Threshold is
3612  *	implementation specific.
3613  * @publish_bcast: if true, the solicited publish should be broadcasted
3614  * @subscribe_active: if true, the subscribe is active
3615  * @followup_id: the instance ID for follow up
3616  * @followup_reqid: the requestor instance ID for follow up
3617  * @followup_dest: MAC address of the recipient of the follow up
3618  * @ttl: time to live counter in DW.
3619  * @serv_spec_info: Service Specific Info
3620  * @serv_spec_info_len: Service Specific Info length
3621  * @srf_include: if true, SRF is inclusive
3622  * @srf_bf: Bloom Filter
3623  * @srf_bf_len: Bloom Filter length
3624  * @srf_bf_idx: Bloom Filter index
3625  * @srf_macs: SRF MAC addresses
3626  * @srf_num_macs: number of MAC addresses in SRF
3627  * @rx_filters: rx filters that are matched with corresponding peer's tx_filter
3628  * @tx_filters: filters that should be transmitted in the SDF.
3629  * @num_rx_filters: length of &rx_filters.
3630  * @num_tx_filters: length of &tx_filters.
3631  * @instance_id: driver allocated id of the function.
3632  * @cookie: unique NAN function identifier.
3633  */
3634 struct cfg80211_nan_func {
3635 	enum nl80211_nan_function_type type;
3636 	u8 service_id[NL80211_NAN_FUNC_SERVICE_ID_LEN];
3637 	u8 publish_type;
3638 	bool close_range;
3639 	bool publish_bcast;
3640 	bool subscribe_active;
3641 	u8 followup_id;
3642 	u8 followup_reqid;
3643 	struct mac_address followup_dest;
3644 	u32 ttl;
3645 	const u8 *serv_spec_info;
3646 	u8 serv_spec_info_len;
3647 	bool srf_include;
3648 	const u8 *srf_bf;
3649 	u8 srf_bf_len;
3650 	u8 srf_bf_idx;
3651 	struct mac_address *srf_macs;
3652 	int srf_num_macs;
3653 	struct cfg80211_nan_func_filter *rx_filters;
3654 	struct cfg80211_nan_func_filter *tx_filters;
3655 	u8 num_tx_filters;
3656 	u8 num_rx_filters;
3657 	u8 instance_id;
3658 	u64 cookie;
3659 };
3660 
3661 /**
3662  * struct cfg80211_pmk_conf - PMK configuration
3663  *
3664  * @aa: authenticator address
3665  * @pmk_len: PMK length in bytes.
3666  * @pmk: the PMK material
3667  * @pmk_r0_name: PMK-R0 Name. NULL if not applicable (i.e., the PMK
3668  *	is not PMK-R0). When pmk_r0_name is not NULL, the pmk field
3669  *	holds PMK-R0.
3670  */
3671 struct cfg80211_pmk_conf {
3672 	const u8 *aa;
3673 	u8 pmk_len;
3674 	const u8 *pmk;
3675 	const u8 *pmk_r0_name;
3676 };
3677 
3678 /**
3679  * struct cfg80211_external_auth_params - Trigger External authentication.
3680  *
3681  * Commonly used across the external auth request and event interfaces.
3682  *
3683  * @action: action type / trigger for external authentication. Only significant
3684  *	for the authentication request event interface (driver to user space).
3685  * @bssid: BSSID of the peer with which the authentication has
3686  *	to happen. Used by both the authentication request event and
3687  *	authentication response command interface.
3688  * @ssid: SSID of the AP.  Used by both the authentication request event and
3689  *	authentication response command interface.
3690  * @key_mgmt_suite: AKM suite of the respective authentication. Used by the
3691  *	authentication request event interface.
3692  * @status: status code, %WLAN_STATUS_SUCCESS for successful authentication,
3693  *	use %WLAN_STATUS_UNSPECIFIED_FAILURE if user space cannot give you
3694  *	the real status code for failures. Used only for the authentication
3695  *	response command interface (user space to driver).
3696  * @pmkid: The identifier to refer a PMKSA.
3697  * @mld_addr: MLD address of the peer. Used by the authentication request event
3698  *	interface. Driver indicates this to enable MLO during the authentication
3699  *	offload to user space. Driver shall look at %NL80211_ATTR_MLO_SUPPORT
3700  *	flag capability in NL80211_CMD_CONNECT to know whether the user space
3701  *	supports enabling MLO during the authentication offload.
3702  *	User space should use the address of the interface (on which the
3703  *	authentication request event reported) as self MLD address. User space
3704  *	and driver should use MLD addresses in RA, TA and BSSID fields of
3705  *	authentication frames sent or received via cfg80211. The driver
3706  *	translates the MLD addresses to/from link addresses based on the link
3707  *	chosen for the authentication.
3708  */
3709 struct cfg80211_external_auth_params {
3710 	enum nl80211_external_auth_action action;
3711 	u8 bssid[ETH_ALEN] __aligned(2);
3712 	struct cfg80211_ssid ssid;
3713 	unsigned int key_mgmt_suite;
3714 	u16 status;
3715 	const u8 *pmkid;
3716 	u8 mld_addr[ETH_ALEN] __aligned(2);
3717 };
3718 
3719 /**
3720  * struct cfg80211_ftm_responder_stats - FTM responder statistics
3721  *
3722  * @filled: bitflag of flags using the bits of &enum nl80211_ftm_stats to
3723  *	indicate the relevant values in this struct for them
3724  * @success_num: number of FTM sessions in which all frames were successfully
3725  *	answered
3726  * @partial_num: number of FTM sessions in which part of frames were
3727  *	successfully answered
3728  * @failed_num: number of failed FTM sessions
3729  * @asap_num: number of ASAP FTM sessions
3730  * @non_asap_num: number of  non-ASAP FTM sessions
3731  * @total_duration_ms: total sessions durations - gives an indication
3732  *	of how much time the responder was busy
3733  * @unknown_triggers_num: number of unknown FTM triggers - triggers from
3734  *	initiators that didn't finish successfully the negotiation phase with
3735  *	the responder
3736  * @reschedule_requests_num: number of FTM reschedule requests - initiator asks
3737  *	for a new scheduling although it already has scheduled FTM slot
3738  * @out_of_window_triggers_num: total FTM triggers out of scheduled window
3739  */
3740 struct cfg80211_ftm_responder_stats {
3741 	u32 filled;
3742 	u32 success_num;
3743 	u32 partial_num;
3744 	u32 failed_num;
3745 	u32 asap_num;
3746 	u32 non_asap_num;
3747 	u64 total_duration_ms;
3748 	u32 unknown_triggers_num;
3749 	u32 reschedule_requests_num;
3750 	u32 out_of_window_triggers_num;
3751 };
3752 
3753 /**
3754  * struct cfg80211_pmsr_ftm_result - FTM result
3755  * @failure_reason: if this measurement failed (PMSR status is
3756  *	%NL80211_PMSR_STATUS_FAILURE), this gives a more precise
3757  *	reason than just "failure"
3758  * @burst_index: if reporting partial results, this is the index
3759  *	in [0 .. num_bursts-1] of the burst that's being reported
3760  * @num_ftmr_attempts: number of FTM request frames transmitted
3761  * @num_ftmr_successes: number of FTM request frames acked
3762  * @busy_retry_time: if failure_reason is %NL80211_PMSR_FTM_FAILURE_PEER_BUSY,
3763  *	fill this to indicate in how many seconds a retry is deemed possible
3764  *	by the responder
3765  * @num_bursts_exp: actual number of bursts exponent negotiated
3766  * @burst_duration: actual burst duration negotiated
3767  * @ftms_per_burst: actual FTMs per burst negotiated
3768  * @lci_len: length of LCI information (if present)
3769  * @civicloc_len: length of civic location information (if present)
3770  * @lci: LCI data (may be %NULL)
3771  * @civicloc: civic location data (may be %NULL)
3772  * @rssi_avg: average RSSI over FTM action frames reported
3773  * @rssi_spread: spread of the RSSI over FTM action frames reported
3774  * @tx_rate: bitrate for transmitted FTM action frame response
3775  * @rx_rate: bitrate of received FTM action frame
3776  * @rtt_avg: average of RTTs measured (must have either this or @dist_avg)
3777  * @rtt_variance: variance of RTTs measured (note that standard deviation is
3778  *	the square root of the variance)
3779  * @rtt_spread: spread of the RTTs measured
3780  * @dist_avg: average of distances (mm) measured
3781  *	(must have either this or @rtt_avg)
3782  * @dist_variance: variance of distances measured (see also @rtt_variance)
3783  * @dist_spread: spread of distances measured (see also @rtt_spread)
3784  * @num_ftmr_attempts_valid: @num_ftmr_attempts is valid
3785  * @num_ftmr_successes_valid: @num_ftmr_successes is valid
3786  * @rssi_avg_valid: @rssi_avg is valid
3787  * @rssi_spread_valid: @rssi_spread is valid
3788  * @tx_rate_valid: @tx_rate is valid
3789  * @rx_rate_valid: @rx_rate is valid
3790  * @rtt_avg_valid: @rtt_avg is valid
3791  * @rtt_variance_valid: @rtt_variance is valid
3792  * @rtt_spread_valid: @rtt_spread is valid
3793  * @dist_avg_valid: @dist_avg is valid
3794  * @dist_variance_valid: @dist_variance is valid
3795  * @dist_spread_valid: @dist_spread is valid
3796  */
3797 struct cfg80211_pmsr_ftm_result {
3798 	const u8 *lci;
3799 	const u8 *civicloc;
3800 	unsigned int lci_len;
3801 	unsigned int civicloc_len;
3802 	enum nl80211_peer_measurement_ftm_failure_reasons failure_reason;
3803 	u32 num_ftmr_attempts, num_ftmr_successes;
3804 	s16 burst_index;
3805 	u8 busy_retry_time;
3806 	u8 num_bursts_exp;
3807 	u8 burst_duration;
3808 	u8 ftms_per_burst;
3809 	s32 rssi_avg;
3810 	s32 rssi_spread;
3811 	struct rate_info tx_rate, rx_rate;
3812 	s64 rtt_avg;
3813 	s64 rtt_variance;
3814 	s64 rtt_spread;
3815 	s64 dist_avg;
3816 	s64 dist_variance;
3817 	s64 dist_spread;
3818 
3819 	u16 num_ftmr_attempts_valid:1,
3820 	    num_ftmr_successes_valid:1,
3821 	    rssi_avg_valid:1,
3822 	    rssi_spread_valid:1,
3823 	    tx_rate_valid:1,
3824 	    rx_rate_valid:1,
3825 	    rtt_avg_valid:1,
3826 	    rtt_variance_valid:1,
3827 	    rtt_spread_valid:1,
3828 	    dist_avg_valid:1,
3829 	    dist_variance_valid:1,
3830 	    dist_spread_valid:1;
3831 };
3832 
3833 /**
3834  * struct cfg80211_pmsr_result - peer measurement result
3835  * @addr: address of the peer
3836  * @host_time: host time (use ktime_get_boottime() adjust to the time when the
3837  *	measurement was made)
3838  * @ap_tsf: AP's TSF at measurement time
3839  * @status: status of the measurement
3840  * @final: if reporting partial results, mark this as the last one; if not
3841  *	reporting partial results always set this flag
3842  * @ap_tsf_valid: indicates the @ap_tsf value is valid
3843  * @type: type of the measurement reported, note that we only support reporting
3844  *	one type at a time, but you can report multiple results separately and
3845  *	they're all aggregated for userspace.
3846  * @ftm: FTM result
3847  */
3848 struct cfg80211_pmsr_result {
3849 	u64 host_time, ap_tsf;
3850 	enum nl80211_peer_measurement_status status;
3851 
3852 	u8 addr[ETH_ALEN];
3853 
3854 	u8 final:1,
3855 	   ap_tsf_valid:1;
3856 
3857 	enum nl80211_peer_measurement_type type;
3858 
3859 	union {
3860 		struct cfg80211_pmsr_ftm_result ftm;
3861 	};
3862 };
3863 
3864 /**
3865  * struct cfg80211_pmsr_ftm_request_peer - FTM request data
3866  * @requested: indicates FTM is requested
3867  * @preamble: frame preamble to use
3868  * @burst_period: burst period to use
3869  * @asap: indicates to use ASAP mode
3870  * @num_bursts_exp: number of bursts exponent
3871  * @burst_duration: burst duration
3872  * @ftms_per_burst: number of FTMs per burst
3873  * @ftmr_retries: number of retries for FTM request
3874  * @request_lci: request LCI information
3875  * @request_civicloc: request civic location information
3876  * @trigger_based: use trigger based ranging for the measurement
3877  *		 If neither @trigger_based nor @non_trigger_based is set,
3878  *		 EDCA based ranging will be used.
3879  * @non_trigger_based: use non trigger based ranging for the measurement
3880  *		 If neither @trigger_based nor @non_trigger_based is set,
3881  *		 EDCA based ranging will be used.
3882  * @lmr_feedback: negotiate for I2R LMR feedback. Only valid if either
3883  *		 @trigger_based or @non_trigger_based is set.
3884  * @bss_color: the bss color of the responder. Optional. Set to zero to
3885  *	indicate the driver should set the BSS color. Only valid if
3886  *	@non_trigger_based or @trigger_based is set.
3887  *
3888  * See also nl80211 for the respective attribute documentation.
3889  */
3890 struct cfg80211_pmsr_ftm_request_peer {
3891 	enum nl80211_preamble preamble;
3892 	u16 burst_period;
3893 	u8 requested:1,
3894 	   asap:1,
3895 	   request_lci:1,
3896 	   request_civicloc:1,
3897 	   trigger_based:1,
3898 	   non_trigger_based:1,
3899 	   lmr_feedback:1;
3900 	u8 num_bursts_exp;
3901 	u8 burst_duration;
3902 	u8 ftms_per_burst;
3903 	u8 ftmr_retries;
3904 	u8 bss_color;
3905 };
3906 
3907 /**
3908  * struct cfg80211_pmsr_request_peer - peer data for a peer measurement request
3909  * @addr: MAC address
3910  * @chandef: channel to use
3911  * @report_ap_tsf: report the associated AP's TSF
3912  * @ftm: FTM data, see &struct cfg80211_pmsr_ftm_request_peer
3913  */
3914 struct cfg80211_pmsr_request_peer {
3915 	u8 addr[ETH_ALEN];
3916 	struct cfg80211_chan_def chandef;
3917 	u8 report_ap_tsf:1;
3918 	struct cfg80211_pmsr_ftm_request_peer ftm;
3919 };
3920 
3921 /**
3922  * struct cfg80211_pmsr_request - peer measurement request
3923  * @cookie: cookie, set by cfg80211
3924  * @nl_portid: netlink portid - used by cfg80211
3925  * @drv_data: driver data for this request, if required for aborting,
3926  *	not otherwise freed or anything by cfg80211
3927  * @mac_addr: MAC address used for (randomised) request
3928  * @mac_addr_mask: MAC address mask used for randomisation, bits that
3929  *	are 0 in the mask should be randomised, bits that are 1 should
3930  *	be taken from the @mac_addr
3931  * @list: used by cfg80211 to hold on to the request
3932  * @timeout: timeout (in milliseconds) for the whole operation, if
3933  *	zero it means there's no timeout
3934  * @n_peers: number of peers to do measurements with
3935  * @peers: per-peer measurement request data
3936  */
3937 struct cfg80211_pmsr_request {
3938 	u64 cookie;
3939 	void *drv_data;
3940 	u32 n_peers;
3941 	u32 nl_portid;
3942 
3943 	u32 timeout;
3944 
3945 	u8 mac_addr[ETH_ALEN] __aligned(2);
3946 	u8 mac_addr_mask[ETH_ALEN] __aligned(2);
3947 
3948 	struct list_head list;
3949 
3950 	struct cfg80211_pmsr_request_peer peers[] __counted_by(n_peers);
3951 };
3952 
3953 /**
3954  * struct cfg80211_update_owe_info - OWE Information
3955  *
3956  * This structure provides information needed for the drivers to offload OWE
3957  * (Opportunistic Wireless Encryption) processing to the user space.
3958  *
3959  * Commonly used across update_owe_info request and event interfaces.
3960  *
3961  * @peer: MAC address of the peer device for which the OWE processing
3962  *	has to be done.
3963  * @status: status code, %WLAN_STATUS_SUCCESS for successful OWE info
3964  *	processing, use %WLAN_STATUS_UNSPECIFIED_FAILURE if user space
3965  *	cannot give you the real status code for failures. Used only for
3966  *	OWE update request command interface (user space to driver).
3967  * @ie: IEs obtained from the peer or constructed by the user space. These are
3968  *	the IEs of the remote peer in the event from the host driver and
3969  *	the constructed IEs by the user space in the request interface.
3970  * @ie_len: Length of IEs in octets.
3971  * @assoc_link_id: MLO link ID of the AP, with which (re)association requested
3972  *	by peer. This will be filled by driver for both MLO and non-MLO station
3973  *	connections when the AP affiliated with an MLD. For non-MLD AP mode, it
3974  *	will be -1. Used only with OWE update event (driver to user space).
3975  * @peer_mld_addr: For MLO connection, MLD address of the peer. For non-MLO
3976  *	connection, it will be all zeros. This is applicable only when
3977  *	@assoc_link_id is not -1, i.e., the AP affiliated with an MLD. Used only
3978  *	with OWE update event (driver to user space).
3979  */
3980 struct cfg80211_update_owe_info {
3981 	u8 peer[ETH_ALEN] __aligned(2);
3982 	u16 status;
3983 	const u8 *ie;
3984 	size_t ie_len;
3985 	int assoc_link_id;
3986 	u8 peer_mld_addr[ETH_ALEN] __aligned(2);
3987 };
3988 
3989 /**
3990  * struct mgmt_frame_regs - management frame registrations data
3991  * @global_stypes: bitmap of management frame subtypes registered
3992  *	for the entire device
3993  * @interface_stypes: bitmap of management frame subtypes registered
3994  *	for the given interface
3995  * @global_mcast_stypes: mcast RX is needed globally for these subtypes
3996  * @interface_mcast_stypes: mcast RX is needed on this interface
3997  *	for these subtypes
3998  */
3999 struct mgmt_frame_regs {
4000 	u32 global_stypes, interface_stypes;
4001 	u32 global_mcast_stypes, interface_mcast_stypes;
4002 };
4003 
4004 /**
4005  * struct cfg80211_ops - backend description for wireless configuration
4006  *
4007  * This struct is registered by fullmac card drivers and/or wireless stacks
4008  * in order to handle configuration requests on their interfaces.
4009  *
4010  * All callbacks except where otherwise noted should return 0
4011  * on success or a negative error code.
4012  *
4013  * All operations are invoked with the wiphy mutex held. The RTNL may be
4014  * held in addition (due to wireless extensions) but this cannot be relied
4015  * upon except in cases where documented below. Note that due to ordering,
4016  * the RTNL also cannot be acquired in any handlers.
4017  *
4018  * @suspend: wiphy device needs to be suspended. The variable @wow will
4019  *	be %NULL or contain the enabled Wake-on-Wireless triggers that are
4020  *	configured for the device.
4021  * @resume: wiphy device needs to be resumed
4022  * @set_wakeup: Called when WoWLAN is enabled/disabled, use this callback
4023  *	to call device_set_wakeup_enable() to enable/disable wakeup from
4024  *	the device.
4025  *
4026  * @add_virtual_intf: create a new virtual interface with the given name,
4027  *	must set the struct wireless_dev's iftype. Beware: You must create
4028  *	the new netdev in the wiphy's network namespace! Returns the struct
4029  *	wireless_dev, or an ERR_PTR. For P2P device wdevs, the driver must
4030  *	also set the address member in the wdev.
4031  *	This additionally holds the RTNL to be able to do netdev changes.
4032  *
4033  * @del_virtual_intf: remove the virtual interface
4034  *	This additionally holds the RTNL to be able to do netdev changes.
4035  *
4036  * @change_virtual_intf: change type/configuration of virtual interface,
4037  *	keep the struct wireless_dev's iftype updated.
4038  *	This additionally holds the RTNL to be able to do netdev changes.
4039  *
4040  * @add_intf_link: Add a new MLO link to the given interface. Note that
4041  *	the wdev->link[] data structure has been updated, so the new link
4042  *	address is available.
4043  * @del_intf_link: Remove an MLO link from the given interface.
4044  *
4045  * @add_key: add a key with the given parameters. @mac_addr will be %NULL
4046  *	when adding a group key. @link_id will be -1 for non-MLO connection.
4047  *	For MLO connection, @link_id will be >= 0 for group key and -1 for
4048  *	pairwise key, @mac_addr will be peer's MLD address for MLO pairwise key.
4049  *
4050  * @get_key: get information about the key with the given parameters.
4051  *	@mac_addr will be %NULL when requesting information for a group
4052  *	key. All pointers given to the @callback function need not be valid
4053  *	after it returns. This function should return an error if it is
4054  *	not possible to retrieve the key, -ENOENT if it doesn't exist.
4055  *	@link_id will be -1 for non-MLO connection. For MLO connection,
4056  *	@link_id will be >= 0 for group key and -1 for pairwise key, @mac_addr
4057  *	will be peer's MLD address for MLO pairwise key.
4058  *
4059  * @del_key: remove a key given the @mac_addr (%NULL for a group key)
4060  *	and @key_index, return -ENOENT if the key doesn't exist. @link_id will
4061  *	be -1 for non-MLO connection. For MLO connection, @link_id will be >= 0
4062  *	for group key and -1 for pairwise key, @mac_addr will be peer's MLD
4063  *	address for MLO pairwise key.
4064  *
4065  * @set_default_key: set the default key on an interface. @link_id will be >= 0
4066  *	for MLO connection and -1 for non-MLO connection.
4067  *
4068  * @set_default_mgmt_key: set the default management frame key on an interface.
4069  *	@link_id will be >= 0 for MLO connection and -1 for non-MLO connection.
4070  *
4071  * @set_default_beacon_key: set the default Beacon frame key on an interface.
4072  *	@link_id will be >= 0 for MLO connection and -1 for non-MLO connection.
4073  *
4074  * @set_rekey_data: give the data necessary for GTK rekeying to the driver
4075  *
4076  * @start_ap: Start acting in AP mode defined by the parameters.
4077  * @change_beacon: Change the beacon parameters for an access point mode
4078  *	interface. This should reject the call when AP mode wasn't started.
4079  * @stop_ap: Stop being an AP, including stopping beaconing.
4080  *
4081  * @add_station: Add a new station.
4082  * @del_station: Remove a station
4083  * @change_station: Modify a given station. Note that flags changes are not much
4084  *	validated in cfg80211, in particular the auth/assoc/authorized flags
4085  *	might come to the driver in invalid combinations -- make sure to check
4086  *	them, also against the existing state! Drivers must call
4087  *	cfg80211_check_station_change() to validate the information.
4088  * @get_station: get station information for the station identified by @mac
4089  * @dump_station: dump station callback -- resume dump at index @idx
4090  *
4091  * @add_mpath: add a fixed mesh path
4092  * @del_mpath: delete a given mesh path
4093  * @change_mpath: change a given mesh path
4094  * @get_mpath: get a mesh path for the given parameters
4095  * @dump_mpath: dump mesh path callback -- resume dump at index @idx
4096  * @get_mpp: get a mesh proxy path for the given parameters
4097  * @dump_mpp: dump mesh proxy path callback -- resume dump at index @idx
4098  * @join_mesh: join the mesh network with the specified parameters
4099  *	(invoked with the wireless_dev mutex held)
4100  * @leave_mesh: leave the current mesh network
4101  *	(invoked with the wireless_dev mutex held)
4102  *
4103  * @get_mesh_config: Get the current mesh configuration
4104  *
4105  * @update_mesh_config: Update mesh parameters on a running mesh.
4106  *	The mask is a bitfield which tells us which parameters to
4107  *	set, and which to leave alone.
4108  *
4109  * @change_bss: Modify parameters for a given BSS.
4110  *
4111  * @inform_bss: Called by cfg80211 while being informed about new BSS data
4112  *	for every BSS found within the reported data or frame. This is called
4113  *	from within the cfg8011 inform_bss handlers while holding the bss_lock.
4114  *	The data parameter is passed through from drv_data inside
4115  *	struct cfg80211_inform_bss.
4116  *	The new IE data for the BSS is explicitly passed.
4117  *
4118  * @set_txq_params: Set TX queue parameters
4119  *
4120  * @libertas_set_mesh_channel: Only for backward compatibility for libertas,
4121  *	as it doesn't implement join_mesh and needs to set the channel to
4122  *	join the mesh instead.
4123  *
4124  * @set_monitor_channel: Set the monitor mode channel for the device. If other
4125  *	interfaces are active this callback should reject the configuration.
4126  *	If no interfaces are active or the device is down, the channel should
4127  *	be stored for when a monitor interface becomes active.
4128  *
4129  * @scan: Request to do a scan. If returning zero, the scan request is given
4130  *	the driver, and will be valid until passed to cfg80211_scan_done().
4131  *	For scan results, call cfg80211_inform_bss(); you can call this outside
4132  *	the scan/scan_done bracket too.
4133  * @abort_scan: Tell the driver to abort an ongoing scan. The driver shall
4134  *	indicate the status of the scan through cfg80211_scan_done().
4135  *
4136  * @auth: Request to authenticate with the specified peer
4137  *	(invoked with the wireless_dev mutex held)
4138  * @assoc: Request to (re)associate with the specified peer
4139  *	(invoked with the wireless_dev mutex held)
4140  * @deauth: Request to deauthenticate from the specified peer
4141  *	(invoked with the wireless_dev mutex held)
4142  * @disassoc: Request to disassociate from the specified peer
4143  *	(invoked with the wireless_dev mutex held)
4144  *
4145  * @connect: Connect to the ESS with the specified parameters. When connected,
4146  *	call cfg80211_connect_result()/cfg80211_connect_bss() with status code
4147  *	%WLAN_STATUS_SUCCESS. If the connection fails for some reason, call
4148  *	cfg80211_connect_result()/cfg80211_connect_bss() with the status code
4149  *	from the AP or cfg80211_connect_timeout() if no frame with status code
4150  *	was received.
4151  *	The driver is allowed to roam to other BSSes within the ESS when the
4152  *	other BSS matches the connect parameters. When such roaming is initiated
4153  *	by the driver, the driver is expected to verify that the target matches
4154  *	the configured security parameters and to use Reassociation Request
4155  *	frame instead of Association Request frame.
4156  *	The connect function can also be used to request the driver to perform a
4157  *	specific roam when connected to an ESS. In that case, the prev_bssid
4158  *	parameter is set to the BSSID of the currently associated BSS as an
4159  *	indication of requesting reassociation.
4160  *	In both the driver-initiated and new connect() call initiated roaming
4161  *	cases, the result of roaming is indicated with a call to
4162  *	cfg80211_roamed(). (invoked with the wireless_dev mutex held)
4163  * @update_connect_params: Update the connect parameters while connected to a
4164  *	BSS. The updated parameters can be used by driver/firmware for
4165  *	subsequent BSS selection (roaming) decisions and to form the
4166  *	Authentication/(Re)Association Request frames. This call does not
4167  *	request an immediate disassociation or reassociation with the current
4168  *	BSS, i.e., this impacts only subsequent (re)associations. The bits in
4169  *	changed are defined in &enum cfg80211_connect_params_changed.
4170  *	(invoked with the wireless_dev mutex held)
4171  * @disconnect: Disconnect from the BSS/ESS or stop connection attempts if
4172  *      connection is in progress. Once done, call cfg80211_disconnected() in
4173  *      case connection was already established (invoked with the
4174  *      wireless_dev mutex held), otherwise call cfg80211_connect_timeout().
4175  *
4176  * @join_ibss: Join the specified IBSS (or create if necessary). Once done, call
4177  *	cfg80211_ibss_joined(), also call that function when changing BSSID due
4178  *	to a merge.
4179  *	(invoked with the wireless_dev mutex held)
4180  * @leave_ibss: Leave the IBSS.
4181  *	(invoked with the wireless_dev mutex held)
4182  *
4183  * @set_mcast_rate: Set the specified multicast rate (only if vif is in ADHOC or
4184  *	MESH mode)
4185  *
4186  * @set_wiphy_params: Notify that wiphy parameters have changed;
4187  *	@changed bitfield (see &enum wiphy_params_flags) describes which values
4188  *	have changed. The actual parameter values are available in
4189  *	struct wiphy. If returning an error, no value should be changed.
4190  *
4191  * @set_tx_power: set the transmit power according to the parameters,
4192  *	the power passed is in mBm, to get dBm use MBM_TO_DBM(). The
4193  *	wdev may be %NULL if power was set for the wiphy, and will
4194  *	always be %NULL unless the driver supports per-vif TX power
4195  *	(as advertised by the nl80211 feature flag.)
4196  * @get_tx_power: store the current TX power into the dbm variable;
4197  *	return 0 if successful
4198  *
4199  * @rfkill_poll: polls the hw rfkill line, use cfg80211 reporting
4200  *	functions to adjust rfkill hw state
4201  *
4202  * @dump_survey: get site survey information.
4203  *
4204  * @remain_on_channel: Request the driver to remain awake on the specified
4205  *	channel for the specified duration to complete an off-channel
4206  *	operation (e.g., public action frame exchange). When the driver is
4207  *	ready on the requested channel, it must indicate this with an event
4208  *	notification by calling cfg80211_ready_on_channel().
4209  * @cancel_remain_on_channel: Cancel an on-going remain-on-channel operation.
4210  *	This allows the operation to be terminated prior to timeout based on
4211  *	the duration value.
4212  * @mgmt_tx: Transmit a management frame.
4213  * @mgmt_tx_cancel_wait: Cancel the wait time from transmitting a management
4214  *	frame on another channel
4215  *
4216  * @testmode_cmd: run a test mode command; @wdev may be %NULL
4217  * @testmode_dump: Implement a test mode dump. The cb->args[2] and up may be
4218  *	used by the function, but 0 and 1 must not be touched. Additionally,
4219  *	return error codes other than -ENOBUFS and -ENOENT will terminate the
4220  *	dump and return to userspace with an error, so be careful. If any data
4221  *	was passed in from userspace then the data/len arguments will be present
4222  *	and point to the data contained in %NL80211_ATTR_TESTDATA.
4223  *
4224  * @set_bitrate_mask: set the bitrate mask configuration
4225  *
4226  * @set_pmksa: Cache a PMKID for a BSSID. This is mostly useful for fullmac
4227  *	devices running firmwares capable of generating the (re) association
4228  *	RSN IE. It allows for faster roaming between WPA2 BSSIDs.
4229  * @del_pmksa: Delete a cached PMKID.
4230  * @flush_pmksa: Flush all cached PMKIDs.
4231  * @set_power_mgmt: Configure WLAN power management. A timeout value of -1
4232  *	allows the driver to adjust the dynamic ps timeout value.
4233  * @set_cqm_rssi_config: Configure connection quality monitor RSSI threshold.
4234  *	After configuration, the driver should (soon) send an event indicating
4235  *	the current level is above/below the configured threshold; this may
4236  *	need some care when the configuration is changed (without first being
4237  *	disabled.)
4238  * @set_cqm_rssi_range_config: Configure two RSSI thresholds in the
4239  *	connection quality monitor.  An event is to be sent only when the
4240  *	signal level is found to be outside the two values.  The driver should
4241  *	set %NL80211_EXT_FEATURE_CQM_RSSI_LIST if this method is implemented.
4242  *	If it is provided then there's no point providing @set_cqm_rssi_config.
4243  * @set_cqm_txe_config: Configure connection quality monitor TX error
4244  *	thresholds.
4245  * @sched_scan_start: Tell the driver to start a scheduled scan.
4246  * @sched_scan_stop: Tell the driver to stop an ongoing scheduled scan with
4247  *	given request id. This call must stop the scheduled scan and be ready
4248  *	for starting a new one before it returns, i.e. @sched_scan_start may be
4249  *	called immediately after that again and should not fail in that case.
4250  *	The driver should not call cfg80211_sched_scan_stopped() for a requested
4251  *	stop (when this method returns 0).
4252  *
4253  * @update_mgmt_frame_registrations: Notify the driver that management frame
4254  *	registrations were updated. The callback is allowed to sleep.
4255  *
4256  * @set_antenna: Set antenna configuration (tx_ant, rx_ant) on the device.
4257  *	Parameters are bitmaps of allowed antennas to use for TX/RX. Drivers may
4258  *	reject TX/RX mask combinations they cannot support by returning -EINVAL
4259  *	(also see nl80211.h @NL80211_ATTR_WIPHY_ANTENNA_TX).
4260  *
4261  * @get_antenna: Get current antenna configuration from device (tx_ant, rx_ant).
4262  *
4263  * @tdls_mgmt: Transmit a TDLS management frame.
4264  * @tdls_oper: Perform a high-level TDLS operation (e.g. TDLS link setup).
4265  *
4266  * @probe_client: probe an associated client, must return a cookie that it
4267  *	later passes to cfg80211_probe_status().
4268  *
4269  * @set_noack_map: Set the NoAck Map for the TIDs.
4270  *
4271  * @get_channel: Get the current operating channel for the virtual interface.
4272  *	For monitor interfaces, it should return %NULL unless there's a single
4273  *	current monitoring channel.
4274  *
4275  * @start_p2p_device: Start the given P2P device.
4276  * @stop_p2p_device: Stop the given P2P device.
4277  *
4278  * @set_mac_acl: Sets MAC address control list in AP and P2P GO mode.
4279  *	Parameters include ACL policy, an array of MAC address of stations
4280  *	and the number of MAC addresses. If there is already a list in driver
4281  *	this new list replaces the existing one. Driver has to clear its ACL
4282  *	when number of MAC addresses entries is passed as 0. Drivers which
4283  *	advertise the support for MAC based ACL have to implement this callback.
4284  *
4285  * @start_radar_detection: Start radar detection in the driver.
4286  *
4287  * @end_cac: End running CAC, probably because a related CAC
4288  *	was finished on another phy.
4289  *
4290  * @update_ft_ies: Provide updated Fast BSS Transition information to the
4291  *	driver. If the SME is in the driver/firmware, this information can be
4292  *	used in building Authentication and Reassociation Request frames.
4293  *
4294  * @crit_proto_start: Indicates a critical protocol needs more link reliability
4295  *	for a given duration (milliseconds). The protocol is provided so the
4296  *	driver can take the most appropriate actions.
4297  * @crit_proto_stop: Indicates critical protocol no longer needs increased link
4298  *	reliability. This operation can not fail.
4299  * @set_coalesce: Set coalesce parameters.
4300  *
4301  * @channel_switch: initiate channel-switch procedure (with CSA). Driver is
4302  *	responsible for veryfing if the switch is possible. Since this is
4303  *	inherently tricky driver may decide to disconnect an interface later
4304  *	with cfg80211_stop_iface(). This doesn't mean driver can accept
4305  *	everything. It should do it's best to verify requests and reject them
4306  *	as soon as possible.
4307  *
4308  * @set_qos_map: Set QoS mapping information to the driver
4309  *
4310  * @set_ap_chanwidth: Set the AP (including P2P GO) mode channel width for the
4311  *	given interface This is used e.g. for dynamic HT 20/40 MHz channel width
4312  *	changes during the lifetime of the BSS.
4313  *
4314  * @add_tx_ts: validate (if admitted_time is 0) or add a TX TS to the device
4315  *	with the given parameters; action frame exchange has been handled by
4316  *	userspace so this just has to modify the TX path to take the TS into
4317  *	account.
4318  *	If the admitted time is 0 just validate the parameters to make sure
4319  *	the session can be created at all; it is valid to just always return
4320  *	success for that but that may result in inefficient behaviour (handshake
4321  *	with the peer followed by immediate teardown when the addition is later
4322  *	rejected)
4323  * @del_tx_ts: remove an existing TX TS
4324  *
4325  * @join_ocb: join the OCB network with the specified parameters
4326  *	(invoked with the wireless_dev mutex held)
4327  * @leave_ocb: leave the current OCB network
4328  *	(invoked with the wireless_dev mutex held)
4329  *
4330  * @tdls_channel_switch: Start channel-switching with a TDLS peer. The driver
4331  *	is responsible for continually initiating channel-switching operations
4332  *	and returning to the base channel for communication with the AP.
4333  * @tdls_cancel_channel_switch: Stop channel-switching with a TDLS peer. Both
4334  *	peers must be on the base channel when the call completes.
4335  * @start_nan: Start the NAN interface.
4336  * @stop_nan: Stop the NAN interface.
4337  * @add_nan_func: Add a NAN function. Returns negative value on failure.
4338  *	On success @nan_func ownership is transferred to the driver and
4339  *	it may access it outside of the scope of this function. The driver
4340  *	should free the @nan_func when no longer needed by calling
4341  *	cfg80211_free_nan_func().
4342  *	On success the driver should assign an instance_id in the
4343  *	provided @nan_func.
4344  * @del_nan_func: Delete a NAN function.
4345  * @nan_change_conf: changes NAN configuration. The changed parameters must
4346  *	be specified in @changes (using &enum cfg80211_nan_conf_changes);
4347  *	All other parameters must be ignored.
4348  *
4349  * @set_multicast_to_unicast: configure multicast to unicast conversion for BSS
4350  *
4351  * @get_txq_stats: Get TXQ stats for interface or phy. If wdev is %NULL, this
4352  *      function should return phy stats, and interface stats otherwise.
4353  *
4354  * @set_pmk: configure the PMK to be used for offloaded 802.1X 4-Way handshake.
4355  *	If not deleted through @del_pmk the PMK remains valid until disconnect
4356  *	upon which the driver should clear it.
4357  *	(invoked with the wireless_dev mutex held)
4358  * @del_pmk: delete the previously configured PMK for the given authenticator.
4359  *	(invoked with the wireless_dev mutex held)
4360  *
4361  * @external_auth: indicates result of offloaded authentication processing from
4362  *     user space
4363  *
4364  * @tx_control_port: TX a control port frame (EAPoL).  The noencrypt parameter
4365  *	tells the driver that the frame should not be encrypted.
4366  *
4367  * @get_ftm_responder_stats: Retrieve FTM responder statistics, if available.
4368  *	Statistics should be cumulative, currently no way to reset is provided.
4369  * @start_pmsr: start peer measurement (e.g. FTM)
4370  * @abort_pmsr: abort peer measurement
4371  *
4372  * @update_owe_info: Provide updated OWE info to driver. Driver implementing SME
4373  *	but offloading OWE processing to the user space will get the updated
4374  *	DH IE through this interface.
4375  *
4376  * @probe_mesh_link: Probe direct Mesh peer's link quality by sending data frame
4377  *	and overrule HWMP path selection algorithm.
4378  * @set_tid_config: TID specific configuration, this can be peer or BSS specific
4379  *	This callback may sleep.
4380  * @reset_tid_config: Reset TID specific configuration for the peer, for the
4381  *	given TIDs. This callback may sleep.
4382  *
4383  * @set_sar_specs: Update the SAR (TX power) settings.
4384  *
4385  * @color_change: Initiate a color change.
4386  *
4387  * @set_fils_aad: Set FILS AAD data to the AP driver so that the driver can use
4388  *	those to decrypt (Re)Association Request and encrypt (Re)Association
4389  *	Response frame.
4390  *
4391  * @set_radar_background: Configure dedicated offchannel chain available for
4392  *	radar/CAC detection on some hw. This chain can't be used to transmit
4393  *	or receive frames and it is bounded to a running wdev.
4394  *	Background radar/CAC detection allows to avoid the CAC downtime
4395  *	switching to a different channel during CAC detection on the selected
4396  *	radar channel.
4397  *	The caller is expected to set chandef pointer to NULL in order to
4398  *	disable background CAC/radar detection.
4399  * @add_link_station: Add a link to a station.
4400  * @mod_link_station: Modify a link of a station.
4401  * @del_link_station: Remove a link of a station.
4402  *
4403  * @set_hw_timestamp: Enable/disable HW timestamping of TM/FTM frames.
4404  */
4405 struct cfg80211_ops {
4406 	int	(*suspend)(struct wiphy *wiphy, struct cfg80211_wowlan *wow);
4407 	int	(*resume)(struct wiphy *wiphy);
4408 	void	(*set_wakeup)(struct wiphy *wiphy, bool enabled);
4409 
4410 	struct wireless_dev * (*add_virtual_intf)(struct wiphy *wiphy,
4411 						  const char *name,
4412 						  unsigned char name_assign_type,
4413 						  enum nl80211_iftype type,
4414 						  struct vif_params *params);
4415 	int	(*del_virtual_intf)(struct wiphy *wiphy,
4416 				    struct wireless_dev *wdev);
4417 	int	(*change_virtual_intf)(struct wiphy *wiphy,
4418 				       struct net_device *dev,
4419 				       enum nl80211_iftype type,
4420 				       struct vif_params *params);
4421 
4422 	int	(*add_intf_link)(struct wiphy *wiphy,
4423 				 struct wireless_dev *wdev,
4424 				 unsigned int link_id);
4425 	void	(*del_intf_link)(struct wiphy *wiphy,
4426 				 struct wireless_dev *wdev,
4427 				 unsigned int link_id);
4428 
4429 	int	(*add_key)(struct wiphy *wiphy, struct net_device *netdev,
4430 			   int link_id, u8 key_index, bool pairwise,
4431 			   const u8 *mac_addr, struct key_params *params);
4432 	int	(*get_key)(struct wiphy *wiphy, struct net_device *netdev,
4433 			   int link_id, u8 key_index, bool pairwise,
4434 			   const u8 *mac_addr, void *cookie,
4435 			   void (*callback)(void *cookie, struct key_params*));
4436 	int	(*del_key)(struct wiphy *wiphy, struct net_device *netdev,
4437 			   int link_id, u8 key_index, bool pairwise,
4438 			   const u8 *mac_addr);
4439 	int	(*set_default_key)(struct wiphy *wiphy,
4440 				   struct net_device *netdev, int link_id,
4441 				   u8 key_index, bool unicast, bool multicast);
4442 	int	(*set_default_mgmt_key)(struct wiphy *wiphy,
4443 					struct net_device *netdev, int link_id,
4444 					u8 key_index);
4445 	int	(*set_default_beacon_key)(struct wiphy *wiphy,
4446 					  struct net_device *netdev,
4447 					  int link_id,
4448 					  u8 key_index);
4449 
4450 	int	(*start_ap)(struct wiphy *wiphy, struct net_device *dev,
4451 			    struct cfg80211_ap_settings *settings);
4452 	int	(*change_beacon)(struct wiphy *wiphy, struct net_device *dev,
4453 				 struct cfg80211_beacon_data *info);
4454 	int	(*stop_ap)(struct wiphy *wiphy, struct net_device *dev,
4455 			   unsigned int link_id);
4456 
4457 
4458 	int	(*add_station)(struct wiphy *wiphy, struct net_device *dev,
4459 			       const u8 *mac,
4460 			       struct station_parameters *params);
4461 	int	(*del_station)(struct wiphy *wiphy, struct net_device *dev,
4462 			       struct station_del_parameters *params);
4463 	int	(*change_station)(struct wiphy *wiphy, struct net_device *dev,
4464 				  const u8 *mac,
4465 				  struct station_parameters *params);
4466 	int	(*get_station)(struct wiphy *wiphy, struct net_device *dev,
4467 			       const u8 *mac, struct station_info *sinfo);
4468 	int	(*dump_station)(struct wiphy *wiphy, struct net_device *dev,
4469 				int idx, u8 *mac, struct station_info *sinfo);
4470 
4471 	int	(*add_mpath)(struct wiphy *wiphy, struct net_device *dev,
4472 			       const u8 *dst, const u8 *next_hop);
4473 	int	(*del_mpath)(struct wiphy *wiphy, struct net_device *dev,
4474 			       const u8 *dst);
4475 	int	(*change_mpath)(struct wiphy *wiphy, struct net_device *dev,
4476 				  const u8 *dst, const u8 *next_hop);
4477 	int	(*get_mpath)(struct wiphy *wiphy, struct net_device *dev,
4478 			     u8 *dst, u8 *next_hop, struct mpath_info *pinfo);
4479 	int	(*dump_mpath)(struct wiphy *wiphy, struct net_device *dev,
4480 			      int idx, u8 *dst, u8 *next_hop,
4481 			      struct mpath_info *pinfo);
4482 	int	(*get_mpp)(struct wiphy *wiphy, struct net_device *dev,
4483 			   u8 *dst, u8 *mpp, struct mpath_info *pinfo);
4484 	int	(*dump_mpp)(struct wiphy *wiphy, struct net_device *dev,
4485 			    int idx, u8 *dst, u8 *mpp,
4486 			    struct mpath_info *pinfo);
4487 	int	(*get_mesh_config)(struct wiphy *wiphy,
4488 				struct net_device *dev,
4489 				struct mesh_config *conf);
4490 	int	(*update_mesh_config)(struct wiphy *wiphy,
4491 				      struct net_device *dev, u32 mask,
4492 				      const struct mesh_config *nconf);
4493 	int	(*join_mesh)(struct wiphy *wiphy, struct net_device *dev,
4494 			     const struct mesh_config *conf,
4495 			     const struct mesh_setup *setup);
4496 	int	(*leave_mesh)(struct wiphy *wiphy, struct net_device *dev);
4497 
4498 	int	(*join_ocb)(struct wiphy *wiphy, struct net_device *dev,
4499 			    struct ocb_setup *setup);
4500 	int	(*leave_ocb)(struct wiphy *wiphy, struct net_device *dev);
4501 
4502 	int	(*change_bss)(struct wiphy *wiphy, struct net_device *dev,
4503 			      struct bss_parameters *params);
4504 
4505 	void	(*inform_bss)(struct wiphy *wiphy, struct cfg80211_bss *bss,
4506 			      const struct cfg80211_bss_ies *ies, void *data);
4507 
4508 	int	(*set_txq_params)(struct wiphy *wiphy, struct net_device *dev,
4509 				  struct ieee80211_txq_params *params);
4510 
4511 	int	(*libertas_set_mesh_channel)(struct wiphy *wiphy,
4512 					     struct net_device *dev,
4513 					     struct ieee80211_channel *chan);
4514 
4515 	int	(*set_monitor_channel)(struct wiphy *wiphy,
4516 				       struct cfg80211_chan_def *chandef);
4517 
4518 	int	(*scan)(struct wiphy *wiphy,
4519 			struct cfg80211_scan_request *request);
4520 	void	(*abort_scan)(struct wiphy *wiphy, struct wireless_dev *wdev);
4521 
4522 	int	(*auth)(struct wiphy *wiphy, struct net_device *dev,
4523 			struct cfg80211_auth_request *req);
4524 	int	(*assoc)(struct wiphy *wiphy, struct net_device *dev,
4525 			 struct cfg80211_assoc_request *req);
4526 	int	(*deauth)(struct wiphy *wiphy, struct net_device *dev,
4527 			  struct cfg80211_deauth_request *req);
4528 	int	(*disassoc)(struct wiphy *wiphy, struct net_device *dev,
4529 			    struct cfg80211_disassoc_request *req);
4530 
4531 	int	(*connect)(struct wiphy *wiphy, struct net_device *dev,
4532 			   struct cfg80211_connect_params *sme);
4533 	int	(*update_connect_params)(struct wiphy *wiphy,
4534 					 struct net_device *dev,
4535 					 struct cfg80211_connect_params *sme,
4536 					 u32 changed);
4537 	int	(*disconnect)(struct wiphy *wiphy, struct net_device *dev,
4538 			      u16 reason_code);
4539 
4540 	int	(*join_ibss)(struct wiphy *wiphy, struct net_device *dev,
4541 			     struct cfg80211_ibss_params *params);
4542 	int	(*leave_ibss)(struct wiphy *wiphy, struct net_device *dev);
4543 
4544 	int	(*set_mcast_rate)(struct wiphy *wiphy, struct net_device *dev,
4545 				  int rate[NUM_NL80211_BANDS]);
4546 
4547 	int	(*set_wiphy_params)(struct wiphy *wiphy, u32 changed);
4548 
4549 	int	(*set_tx_power)(struct wiphy *wiphy, struct wireless_dev *wdev,
4550 				enum nl80211_tx_power_setting type, int mbm);
4551 	int	(*get_tx_power)(struct wiphy *wiphy, struct wireless_dev *wdev,
4552 				int *dbm);
4553 
4554 	void	(*rfkill_poll)(struct wiphy *wiphy);
4555 
4556 #ifdef CONFIG_NL80211_TESTMODE
4557 	int	(*testmode_cmd)(struct wiphy *wiphy, struct wireless_dev *wdev,
4558 				void *data, int len);
4559 	int	(*testmode_dump)(struct wiphy *wiphy, struct sk_buff *skb,
4560 				 struct netlink_callback *cb,
4561 				 void *data, int len);
4562 #endif
4563 
4564 	int	(*set_bitrate_mask)(struct wiphy *wiphy,
4565 				    struct net_device *dev,
4566 				    unsigned int link_id,
4567 				    const u8 *peer,
4568 				    const struct cfg80211_bitrate_mask *mask);
4569 
4570 	int	(*dump_survey)(struct wiphy *wiphy, struct net_device *netdev,
4571 			int idx, struct survey_info *info);
4572 
4573 	int	(*set_pmksa)(struct wiphy *wiphy, struct net_device *netdev,
4574 			     struct cfg80211_pmksa *pmksa);
4575 	int	(*del_pmksa)(struct wiphy *wiphy, struct net_device *netdev,
4576 			     struct cfg80211_pmksa *pmksa);
4577 	int	(*flush_pmksa)(struct wiphy *wiphy, struct net_device *netdev);
4578 
4579 	int	(*remain_on_channel)(struct wiphy *wiphy,
4580 				     struct wireless_dev *wdev,
4581 				     struct ieee80211_channel *chan,
4582 				     unsigned int duration,
4583 				     u64 *cookie);
4584 	int	(*cancel_remain_on_channel)(struct wiphy *wiphy,
4585 					    struct wireless_dev *wdev,
4586 					    u64 cookie);
4587 
4588 	int	(*mgmt_tx)(struct wiphy *wiphy, struct wireless_dev *wdev,
4589 			   struct cfg80211_mgmt_tx_params *params,
4590 			   u64 *cookie);
4591 	int	(*mgmt_tx_cancel_wait)(struct wiphy *wiphy,
4592 				       struct wireless_dev *wdev,
4593 				       u64 cookie);
4594 
4595 	int	(*set_power_mgmt)(struct wiphy *wiphy, struct net_device *dev,
4596 				  bool enabled, int timeout);
4597 
4598 	int	(*set_cqm_rssi_config)(struct wiphy *wiphy,
4599 				       struct net_device *dev,
4600 				       s32 rssi_thold, u32 rssi_hyst);
4601 
4602 	int	(*set_cqm_rssi_range_config)(struct wiphy *wiphy,
4603 					     struct net_device *dev,
4604 					     s32 rssi_low, s32 rssi_high);
4605 
4606 	int	(*set_cqm_txe_config)(struct wiphy *wiphy,
4607 				      struct net_device *dev,
4608 				      u32 rate, u32 pkts, u32 intvl);
4609 
4610 	void	(*update_mgmt_frame_registrations)(struct wiphy *wiphy,
4611 						   struct wireless_dev *wdev,
4612 						   struct mgmt_frame_regs *upd);
4613 
4614 	int	(*set_antenna)(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant);
4615 	int	(*get_antenna)(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant);
4616 
4617 	int	(*sched_scan_start)(struct wiphy *wiphy,
4618 				struct net_device *dev,
4619 				struct cfg80211_sched_scan_request *request);
4620 	int	(*sched_scan_stop)(struct wiphy *wiphy, struct net_device *dev,
4621 				   u64 reqid);
4622 
4623 	int	(*set_rekey_data)(struct wiphy *wiphy, struct net_device *dev,
4624 				  struct cfg80211_gtk_rekey_data *data);
4625 
4626 	int	(*tdls_mgmt)(struct wiphy *wiphy, struct net_device *dev,
4627 			     const u8 *peer, int link_id,
4628 			     u8 action_code, u8 dialog_token, u16 status_code,
4629 			     u32 peer_capability, bool initiator,
4630 			     const u8 *buf, size_t len);
4631 	int	(*tdls_oper)(struct wiphy *wiphy, struct net_device *dev,
4632 			     const u8 *peer, enum nl80211_tdls_operation oper);
4633 
4634 	int	(*probe_client)(struct wiphy *wiphy, struct net_device *dev,
4635 				const u8 *peer, u64 *cookie);
4636 
4637 	int	(*set_noack_map)(struct wiphy *wiphy,
4638 				  struct net_device *dev,
4639 				  u16 noack_map);
4640 
4641 	int	(*get_channel)(struct wiphy *wiphy,
4642 			       struct wireless_dev *wdev,
4643 			       unsigned int link_id,
4644 			       struct cfg80211_chan_def *chandef);
4645 
4646 	int	(*start_p2p_device)(struct wiphy *wiphy,
4647 				    struct wireless_dev *wdev);
4648 	void	(*stop_p2p_device)(struct wiphy *wiphy,
4649 				   struct wireless_dev *wdev);
4650 
4651 	int	(*set_mac_acl)(struct wiphy *wiphy, struct net_device *dev,
4652 			       const struct cfg80211_acl_data *params);
4653 
4654 	int	(*start_radar_detection)(struct wiphy *wiphy,
4655 					 struct net_device *dev,
4656 					 struct cfg80211_chan_def *chandef,
4657 					 u32 cac_time_ms);
4658 	void	(*end_cac)(struct wiphy *wiphy,
4659 				struct net_device *dev);
4660 	int	(*update_ft_ies)(struct wiphy *wiphy, struct net_device *dev,
4661 				 struct cfg80211_update_ft_ies_params *ftie);
4662 	int	(*crit_proto_start)(struct wiphy *wiphy,
4663 				    struct wireless_dev *wdev,
4664 				    enum nl80211_crit_proto_id protocol,
4665 				    u16 duration);
4666 	void	(*crit_proto_stop)(struct wiphy *wiphy,
4667 				   struct wireless_dev *wdev);
4668 	int	(*set_coalesce)(struct wiphy *wiphy,
4669 				struct cfg80211_coalesce *coalesce);
4670 
4671 	int	(*channel_switch)(struct wiphy *wiphy,
4672 				  struct net_device *dev,
4673 				  struct cfg80211_csa_settings *params);
4674 
4675 	int     (*set_qos_map)(struct wiphy *wiphy,
4676 			       struct net_device *dev,
4677 			       struct cfg80211_qos_map *qos_map);
4678 
4679 	int	(*set_ap_chanwidth)(struct wiphy *wiphy, struct net_device *dev,
4680 				    unsigned int link_id,
4681 				    struct cfg80211_chan_def *chandef);
4682 
4683 	int	(*add_tx_ts)(struct wiphy *wiphy, struct net_device *dev,
4684 			     u8 tsid, const u8 *peer, u8 user_prio,
4685 			     u16 admitted_time);
4686 	int	(*del_tx_ts)(struct wiphy *wiphy, struct net_device *dev,
4687 			     u8 tsid, const u8 *peer);
4688 
4689 	int	(*tdls_channel_switch)(struct wiphy *wiphy,
4690 				       struct net_device *dev,
4691 				       const u8 *addr, u8 oper_class,
4692 				       struct cfg80211_chan_def *chandef);
4693 	void	(*tdls_cancel_channel_switch)(struct wiphy *wiphy,
4694 					      struct net_device *dev,
4695 					      const u8 *addr);
4696 	int	(*start_nan)(struct wiphy *wiphy, struct wireless_dev *wdev,
4697 			     struct cfg80211_nan_conf *conf);
4698 	void	(*stop_nan)(struct wiphy *wiphy, struct wireless_dev *wdev);
4699 	int	(*add_nan_func)(struct wiphy *wiphy, struct wireless_dev *wdev,
4700 				struct cfg80211_nan_func *nan_func);
4701 	void	(*del_nan_func)(struct wiphy *wiphy, struct wireless_dev *wdev,
4702 			       u64 cookie);
4703 	int	(*nan_change_conf)(struct wiphy *wiphy,
4704 				   struct wireless_dev *wdev,
4705 				   struct cfg80211_nan_conf *conf,
4706 				   u32 changes);
4707 
4708 	int	(*set_multicast_to_unicast)(struct wiphy *wiphy,
4709 					    struct net_device *dev,
4710 					    const bool enabled);
4711 
4712 	int	(*get_txq_stats)(struct wiphy *wiphy,
4713 				 struct wireless_dev *wdev,
4714 				 struct cfg80211_txq_stats *txqstats);
4715 
4716 	int	(*set_pmk)(struct wiphy *wiphy, struct net_device *dev,
4717 			   const struct cfg80211_pmk_conf *conf);
4718 	int	(*del_pmk)(struct wiphy *wiphy, struct net_device *dev,
4719 			   const u8 *aa);
4720 	int     (*external_auth)(struct wiphy *wiphy, struct net_device *dev,
4721 				 struct cfg80211_external_auth_params *params);
4722 
4723 	int	(*tx_control_port)(struct wiphy *wiphy,
4724 				   struct net_device *dev,
4725 				   const u8 *buf, size_t len,
4726 				   const u8 *dest, const __be16 proto,
4727 				   const bool noencrypt, int link_id,
4728 				   u64 *cookie);
4729 
4730 	int	(*get_ftm_responder_stats)(struct wiphy *wiphy,
4731 				struct net_device *dev,
4732 				struct cfg80211_ftm_responder_stats *ftm_stats);
4733 
4734 	int	(*start_pmsr)(struct wiphy *wiphy, struct wireless_dev *wdev,
4735 			      struct cfg80211_pmsr_request *request);
4736 	void	(*abort_pmsr)(struct wiphy *wiphy, struct wireless_dev *wdev,
4737 			      struct cfg80211_pmsr_request *request);
4738 	int	(*update_owe_info)(struct wiphy *wiphy, struct net_device *dev,
4739 				   struct cfg80211_update_owe_info *owe_info);
4740 	int	(*probe_mesh_link)(struct wiphy *wiphy, struct net_device *dev,
4741 				   const u8 *buf, size_t len);
4742 	int     (*set_tid_config)(struct wiphy *wiphy, struct net_device *dev,
4743 				  struct cfg80211_tid_config *tid_conf);
4744 	int	(*reset_tid_config)(struct wiphy *wiphy, struct net_device *dev,
4745 				    const u8 *peer, u8 tids);
4746 	int	(*set_sar_specs)(struct wiphy *wiphy,
4747 				 struct cfg80211_sar_specs *sar);
4748 	int	(*color_change)(struct wiphy *wiphy,
4749 				struct net_device *dev,
4750 				struct cfg80211_color_change_settings *params);
4751 	int     (*set_fils_aad)(struct wiphy *wiphy, struct net_device *dev,
4752 				struct cfg80211_fils_aad *fils_aad);
4753 	int	(*set_radar_background)(struct wiphy *wiphy,
4754 					struct cfg80211_chan_def *chandef);
4755 	int	(*add_link_station)(struct wiphy *wiphy, struct net_device *dev,
4756 				    struct link_station_parameters *params);
4757 	int	(*mod_link_station)(struct wiphy *wiphy, struct net_device *dev,
4758 				    struct link_station_parameters *params);
4759 	int	(*del_link_station)(struct wiphy *wiphy, struct net_device *dev,
4760 				    struct link_station_del_parameters *params);
4761 	int	(*set_hw_timestamp)(struct wiphy *wiphy, struct net_device *dev,
4762 				    struct cfg80211_set_hw_timestamp *hwts);
4763 };
4764 
4765 /*
4766  * wireless hardware and networking interfaces structures
4767  * and registration/helper functions
4768  */
4769 
4770 /**
4771  * enum wiphy_flags - wiphy capability flags
4772  *
4773  * @WIPHY_FLAG_SPLIT_SCAN_6GHZ: if set to true, the scan request will be split
4774  *	 into two, first for legacy bands and second for UHB.
4775  * @WIPHY_FLAG_NETNS_OK: if not set, do not allow changing the netns of this
4776  *	wiphy at all
4777  * @WIPHY_FLAG_PS_ON_BY_DEFAULT: if set to true, powersave will be enabled
4778  *	by default -- this flag will be set depending on the kernel's default
4779  *	on wiphy_new(), but can be changed by the driver if it has a good
4780  *	reason to override the default
4781  * @WIPHY_FLAG_4ADDR_AP: supports 4addr mode even on AP (with a single station
4782  *	on a VLAN interface). This flag also serves an extra purpose of
4783  *	supporting 4ADDR AP mode on devices which do not support AP/VLAN iftype.
4784  * @WIPHY_FLAG_4ADDR_STATION: supports 4addr mode even as a station
4785  * @WIPHY_FLAG_CONTROL_PORT_PROTOCOL: This device supports setting the
4786  *	control port protocol ethertype. The device also honours the
4787  *	control_port_no_encrypt flag.
4788  * @WIPHY_FLAG_IBSS_RSN: The device supports IBSS RSN.
4789  * @WIPHY_FLAG_MESH_AUTH: The device supports mesh authentication by routing
4790  *	auth frames to userspace. See @NL80211_MESH_SETUP_USERSPACE_AUTH.
4791  * @WIPHY_FLAG_SUPPORTS_FW_ROAM: The device supports roaming feature in the
4792  *	firmware.
4793  * @WIPHY_FLAG_AP_UAPSD: The device supports uapsd on AP.
4794  * @WIPHY_FLAG_SUPPORTS_TDLS: The device supports TDLS (802.11z) operation.
4795  * @WIPHY_FLAG_TDLS_EXTERNAL_SETUP: The device does not handle TDLS (802.11z)
4796  *	link setup/discovery operations internally. Setup, discovery and
4797  *	teardown packets should be sent through the @NL80211_CMD_TDLS_MGMT
4798  *	command. When this flag is not set, @NL80211_CMD_TDLS_OPER should be
4799  *	used for asking the driver/firmware to perform a TDLS operation.
4800  * @WIPHY_FLAG_HAVE_AP_SME: device integrates AP SME
4801  * @WIPHY_FLAG_REPORTS_OBSS: the device will report beacons from other BSSes
4802  *	when there are virtual interfaces in AP mode by calling
4803  *	cfg80211_report_obss_beacon().
4804  * @WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD: When operating as an AP, the device
4805  *	responds to probe-requests in hardware.
4806  * @WIPHY_FLAG_OFFCHAN_TX: Device supports direct off-channel TX.
4807  * @WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL: Device supports remain-on-channel call.
4808  * @WIPHY_FLAG_SUPPORTS_5_10_MHZ: Device supports 5 MHz and 10 MHz channels.
4809  * @WIPHY_FLAG_HAS_CHANNEL_SWITCH: Device supports channel switch in
4810  *	beaconing mode (AP, IBSS, Mesh, ...).
4811  * @WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK: The device supports bigger kek and kck keys
4812  * @WIPHY_FLAG_SUPPORTS_MLO: This is a temporary flag gating the MLO APIs,
4813  *	in order to not have them reachable in normal drivers, until we have
4814  *	complete feature/interface combinations/etc. advertisement. No driver
4815  *	should set this flag for now.
4816  * @WIPHY_FLAG_SUPPORTS_EXT_KCK_32: The device supports 32-byte KCK keys.
4817  * @WIPHY_FLAG_NOTIFY_REGDOM_BY_DRIVER: The device could handle reg notify for
4818  *	NL80211_REGDOM_SET_BY_DRIVER.
4819  */
4820 enum wiphy_flags {
4821 	WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK		= BIT(0),
4822 	WIPHY_FLAG_SUPPORTS_MLO			= BIT(1),
4823 	WIPHY_FLAG_SPLIT_SCAN_6GHZ		= BIT(2),
4824 	WIPHY_FLAG_NETNS_OK			= BIT(3),
4825 	WIPHY_FLAG_PS_ON_BY_DEFAULT		= BIT(4),
4826 	WIPHY_FLAG_4ADDR_AP			= BIT(5),
4827 	WIPHY_FLAG_4ADDR_STATION		= BIT(6),
4828 	WIPHY_FLAG_CONTROL_PORT_PROTOCOL	= BIT(7),
4829 	WIPHY_FLAG_IBSS_RSN			= BIT(8),
4830 	WIPHY_FLAG_MESH_AUTH			= BIT(10),
4831 	WIPHY_FLAG_SUPPORTS_EXT_KCK_32          = BIT(11),
4832 	/* use hole at 12 */
4833 	WIPHY_FLAG_SUPPORTS_FW_ROAM		= BIT(13),
4834 	WIPHY_FLAG_AP_UAPSD			= BIT(14),
4835 	WIPHY_FLAG_SUPPORTS_TDLS		= BIT(15),
4836 	WIPHY_FLAG_TDLS_EXTERNAL_SETUP		= BIT(16),
4837 	WIPHY_FLAG_HAVE_AP_SME			= BIT(17),
4838 	WIPHY_FLAG_REPORTS_OBSS			= BIT(18),
4839 	WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD	= BIT(19),
4840 	WIPHY_FLAG_OFFCHAN_TX			= BIT(20),
4841 	WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL	= BIT(21),
4842 	WIPHY_FLAG_SUPPORTS_5_10_MHZ		= BIT(22),
4843 	WIPHY_FLAG_HAS_CHANNEL_SWITCH		= BIT(23),
4844 	WIPHY_FLAG_NOTIFY_REGDOM_BY_DRIVER	= BIT(24),
4845 };
4846 
4847 /**
4848  * struct ieee80211_iface_limit - limit on certain interface types
4849  * @max: maximum number of interfaces of these types
4850  * @types: interface types (bits)
4851  */
4852 struct ieee80211_iface_limit {
4853 	u16 max;
4854 	u16 types;
4855 };
4856 
4857 /**
4858  * struct ieee80211_iface_combination - possible interface combination
4859  *
4860  * With this structure the driver can describe which interface
4861  * combinations it supports concurrently.
4862  *
4863  * Examples:
4864  *
4865  * 1. Allow #STA <= 1, #AP <= 1, matching BI, channels = 1, 2 total:
4866  *
4867  *    .. code-block:: c
4868  *
4869  *	struct ieee80211_iface_limit limits1[] = {
4870  *		{ .max = 1, .types = BIT(NL80211_IFTYPE_STATION), },
4871  *		{ .max = 1, .types = BIT(NL80211_IFTYPE_AP), },
4872  *	};
4873  *	struct ieee80211_iface_combination combination1 = {
4874  *		.limits = limits1,
4875  *		.n_limits = ARRAY_SIZE(limits1),
4876  *		.max_interfaces = 2,
4877  *		.beacon_int_infra_match = true,
4878  *	};
4879  *
4880  *
4881  * 2. Allow #{AP, P2P-GO} <= 8, channels = 1, 8 total:
4882  *
4883  *    .. code-block:: c
4884  *
4885  *	struct ieee80211_iface_limit limits2[] = {
4886  *		{ .max = 8, .types = BIT(NL80211_IFTYPE_AP) |
4887  *				     BIT(NL80211_IFTYPE_P2P_GO), },
4888  *	};
4889  *	struct ieee80211_iface_combination combination2 = {
4890  *		.limits = limits2,
4891  *		.n_limits = ARRAY_SIZE(limits2),
4892  *		.max_interfaces = 8,
4893  *		.num_different_channels = 1,
4894  *	};
4895  *
4896  *
4897  * 3. Allow #STA <= 1, #{P2P-client,P2P-GO} <= 3 on two channels, 4 total.
4898  *
4899  *    This allows for an infrastructure connection and three P2P connections.
4900  *
4901  *    .. code-block:: c
4902  *
4903  *	struct ieee80211_iface_limit limits3[] = {
4904  *		{ .max = 1, .types = BIT(NL80211_IFTYPE_STATION), },
4905  *		{ .max = 3, .types = BIT(NL80211_IFTYPE_P2P_GO) |
4906  *				     BIT(NL80211_IFTYPE_P2P_CLIENT), },
4907  *	};
4908  *	struct ieee80211_iface_combination combination3 = {
4909  *		.limits = limits3,
4910  *		.n_limits = ARRAY_SIZE(limits3),
4911  *		.max_interfaces = 4,
4912  *		.num_different_channels = 2,
4913  *	};
4914  *
4915  */
4916 struct ieee80211_iface_combination {
4917 	/**
4918 	 * @limits:
4919 	 * limits for the given interface types
4920 	 */
4921 	const struct ieee80211_iface_limit *limits;
4922 
4923 	/**
4924 	 * @num_different_channels:
4925 	 * can use up to this many different channels
4926 	 */
4927 	u32 num_different_channels;
4928 
4929 	/**
4930 	 * @max_interfaces:
4931 	 * maximum number of interfaces in total allowed in this group
4932 	 */
4933 	u16 max_interfaces;
4934 
4935 	/**
4936 	 * @n_limits:
4937 	 * number of limitations
4938 	 */
4939 	u8 n_limits;
4940 
4941 	/**
4942 	 * @beacon_int_infra_match:
4943 	 * In this combination, the beacon intervals between infrastructure
4944 	 * and AP types must match. This is required only in special cases.
4945 	 */
4946 	bool beacon_int_infra_match;
4947 
4948 	/**
4949 	 * @radar_detect_widths:
4950 	 * bitmap of channel widths supported for radar detection
4951 	 */
4952 	u8 radar_detect_widths;
4953 
4954 	/**
4955 	 * @radar_detect_regions:
4956 	 * bitmap of regions supported for radar detection
4957 	 */
4958 	u8 radar_detect_regions;
4959 
4960 	/**
4961 	 * @beacon_int_min_gcd:
4962 	 * This interface combination supports different beacon intervals.
4963 	 *
4964 	 * = 0
4965 	 *   all beacon intervals for different interface must be same.
4966 	 * > 0
4967 	 *   any beacon interval for the interface part of this combination AND
4968 	 *   GCD of all beacon intervals from beaconing interfaces of this
4969 	 *   combination must be greater or equal to this value.
4970 	 */
4971 	u32 beacon_int_min_gcd;
4972 };
4973 
4974 struct ieee80211_txrx_stypes {
4975 	u16 tx, rx;
4976 };
4977 
4978 /**
4979  * enum wiphy_wowlan_support_flags - WoWLAN support flags
4980  * @WIPHY_WOWLAN_ANY: supports wakeup for the special "any"
4981  *	trigger that keeps the device operating as-is and
4982  *	wakes up the host on any activity, for example a
4983  *	received packet that passed filtering; note that the
4984  *	packet should be preserved in that case
4985  * @WIPHY_WOWLAN_MAGIC_PKT: supports wakeup on magic packet
4986  *	(see nl80211.h)
4987  * @WIPHY_WOWLAN_DISCONNECT: supports wakeup on disconnect
4988  * @WIPHY_WOWLAN_SUPPORTS_GTK_REKEY: supports GTK rekeying while asleep
4989  * @WIPHY_WOWLAN_GTK_REKEY_FAILURE: supports wakeup on GTK rekey failure
4990  * @WIPHY_WOWLAN_EAP_IDENTITY_REQ: supports wakeup on EAP identity request
4991  * @WIPHY_WOWLAN_4WAY_HANDSHAKE: supports wakeup on 4-way handshake failure
4992  * @WIPHY_WOWLAN_RFKILL_RELEASE: supports wakeup on RF-kill release
4993  * @WIPHY_WOWLAN_NET_DETECT: supports wakeup on network detection
4994  */
4995 enum wiphy_wowlan_support_flags {
4996 	WIPHY_WOWLAN_ANY		= BIT(0),
4997 	WIPHY_WOWLAN_MAGIC_PKT		= BIT(1),
4998 	WIPHY_WOWLAN_DISCONNECT		= BIT(2),
4999 	WIPHY_WOWLAN_SUPPORTS_GTK_REKEY	= BIT(3),
5000 	WIPHY_WOWLAN_GTK_REKEY_FAILURE	= BIT(4),
5001 	WIPHY_WOWLAN_EAP_IDENTITY_REQ	= BIT(5),
5002 	WIPHY_WOWLAN_4WAY_HANDSHAKE	= BIT(6),
5003 	WIPHY_WOWLAN_RFKILL_RELEASE	= BIT(7),
5004 	WIPHY_WOWLAN_NET_DETECT		= BIT(8),
5005 };
5006 
5007 struct wiphy_wowlan_tcp_support {
5008 	const struct nl80211_wowlan_tcp_data_token_feature *tok;
5009 	u32 data_payload_max;
5010 	u32 data_interval_max;
5011 	u32 wake_payload_max;
5012 	bool seq;
5013 };
5014 
5015 /**
5016  * struct wiphy_wowlan_support - WoWLAN support data
5017  * @flags: see &enum wiphy_wowlan_support_flags
5018  * @n_patterns: number of supported wakeup patterns
5019  *	(see nl80211.h for the pattern definition)
5020  * @pattern_max_len: maximum length of each pattern
5021  * @pattern_min_len: minimum length of each pattern
5022  * @max_pkt_offset: maximum Rx packet offset
5023  * @max_nd_match_sets: maximum number of matchsets for net-detect,
5024  *	similar, but not necessarily identical, to max_match_sets for
5025  *	scheduled scans.
5026  *	See &struct cfg80211_sched_scan_request.@match_sets for more
5027  *	details.
5028  * @tcp: TCP wakeup support information
5029  */
5030 struct wiphy_wowlan_support {
5031 	u32 flags;
5032 	int n_patterns;
5033 	int pattern_max_len;
5034 	int pattern_min_len;
5035 	int max_pkt_offset;
5036 	int max_nd_match_sets;
5037 	const struct wiphy_wowlan_tcp_support *tcp;
5038 };
5039 
5040 /**
5041  * struct wiphy_coalesce_support - coalesce support data
5042  * @n_rules: maximum number of coalesce rules
5043  * @max_delay: maximum supported coalescing delay in msecs
5044  * @n_patterns: number of supported patterns in a rule
5045  *	(see nl80211.h for the pattern definition)
5046  * @pattern_max_len: maximum length of each pattern
5047  * @pattern_min_len: minimum length of each pattern
5048  * @max_pkt_offset: maximum Rx packet offset
5049  */
5050 struct wiphy_coalesce_support {
5051 	int n_rules;
5052 	int max_delay;
5053 	int n_patterns;
5054 	int pattern_max_len;
5055 	int pattern_min_len;
5056 	int max_pkt_offset;
5057 };
5058 
5059 /**
5060  * enum wiphy_vendor_command_flags - validation flags for vendor commands
5061  * @WIPHY_VENDOR_CMD_NEED_WDEV: vendor command requires wdev
5062  * @WIPHY_VENDOR_CMD_NEED_NETDEV: vendor command requires netdev
5063  * @WIPHY_VENDOR_CMD_NEED_RUNNING: interface/wdev must be up & running
5064  *	(must be combined with %_WDEV or %_NETDEV)
5065  */
5066 enum wiphy_vendor_command_flags {
5067 	WIPHY_VENDOR_CMD_NEED_WDEV = BIT(0),
5068 	WIPHY_VENDOR_CMD_NEED_NETDEV = BIT(1),
5069 	WIPHY_VENDOR_CMD_NEED_RUNNING = BIT(2),
5070 };
5071 
5072 /**
5073  * enum wiphy_opmode_flag - Station's ht/vht operation mode information flags
5074  *
5075  * @STA_OPMODE_MAX_BW_CHANGED: Max Bandwidth changed
5076  * @STA_OPMODE_SMPS_MODE_CHANGED: SMPS mode changed
5077  * @STA_OPMODE_N_SS_CHANGED: max N_SS (number of spatial streams) changed
5078  *
5079  */
5080 enum wiphy_opmode_flag {
5081 	STA_OPMODE_MAX_BW_CHANGED	= BIT(0),
5082 	STA_OPMODE_SMPS_MODE_CHANGED	= BIT(1),
5083 	STA_OPMODE_N_SS_CHANGED		= BIT(2),
5084 };
5085 
5086 /**
5087  * struct sta_opmode_info - Station's ht/vht operation mode information
5088  * @changed: contains value from &enum wiphy_opmode_flag
5089  * @smps_mode: New SMPS mode value from &enum nl80211_smps_mode of a station
5090  * @bw: new max bandwidth value from &enum nl80211_chan_width of a station
5091  * @rx_nss: new rx_nss value of a station
5092  */
5093 
5094 struct sta_opmode_info {
5095 	u32 changed;
5096 	enum nl80211_smps_mode smps_mode;
5097 	enum nl80211_chan_width bw;
5098 	u8 rx_nss;
5099 };
5100 
5101 #define VENDOR_CMD_RAW_DATA ((const struct nla_policy *)(long)(-ENODATA))
5102 
5103 /**
5104  * struct wiphy_vendor_command - vendor command definition
5105  * @info: vendor command identifying information, as used in nl80211
5106  * @flags: flags, see &enum wiphy_vendor_command_flags
5107  * @doit: callback for the operation, note that wdev is %NULL if the
5108  *	flags didn't ask for a wdev and non-%NULL otherwise; the data
5109  *	pointer may be %NULL if userspace provided no data at all
5110  * @dumpit: dump callback, for transferring bigger/multiple items. The
5111  *	@storage points to cb->args[5], ie. is preserved over the multiple
5112  *	dumpit calls.
5113  * @policy: policy pointer for attributes within %NL80211_ATTR_VENDOR_DATA.
5114  *	Set this to %VENDOR_CMD_RAW_DATA if no policy can be given and the
5115  *	attribute is just raw data (e.g. a firmware command).
5116  * @maxattr: highest attribute number in policy
5117  * It's recommended to not have the same sub command with both @doit and
5118  * @dumpit, so that userspace can assume certain ones are get and others
5119  * are used with dump requests.
5120  */
5121 struct wiphy_vendor_command {
5122 	struct nl80211_vendor_cmd_info info;
5123 	u32 flags;
5124 	int (*doit)(struct wiphy *wiphy, struct wireless_dev *wdev,
5125 		    const void *data, int data_len);
5126 	int (*dumpit)(struct wiphy *wiphy, struct wireless_dev *wdev,
5127 		      struct sk_buff *skb, const void *data, int data_len,
5128 		      unsigned long *storage);
5129 	const struct nla_policy *policy;
5130 	unsigned int maxattr;
5131 };
5132 
5133 /**
5134  * struct wiphy_iftype_ext_capab - extended capabilities per interface type
5135  * @iftype: interface type
5136  * @extended_capabilities: extended capabilities supported by the driver,
5137  *	additional capabilities might be supported by userspace; these are the
5138  *	802.11 extended capabilities ("Extended Capabilities element") and are
5139  *	in the same format as in the information element. See IEEE Std
5140  *	802.11-2012 8.4.2.29 for the defined fields.
5141  * @extended_capabilities_mask: mask of the valid values
5142  * @extended_capabilities_len: length of the extended capabilities
5143  * @eml_capabilities: EML capabilities (for MLO)
5144  * @mld_capa_and_ops: MLD capabilities and operations (for MLO)
5145  */
5146 struct wiphy_iftype_ext_capab {
5147 	enum nl80211_iftype iftype;
5148 	const u8 *extended_capabilities;
5149 	const u8 *extended_capabilities_mask;
5150 	u8 extended_capabilities_len;
5151 	u16 eml_capabilities;
5152 	u16 mld_capa_and_ops;
5153 };
5154 
5155 /**
5156  * cfg80211_get_iftype_ext_capa - lookup interface type extended capability
5157  * @wiphy: the wiphy to look up from
5158  * @type: the interface type to look up
5159  */
5160 const struct wiphy_iftype_ext_capab *
5161 cfg80211_get_iftype_ext_capa(struct wiphy *wiphy, enum nl80211_iftype type);
5162 
5163 /**
5164  * struct cfg80211_pmsr_capabilities - cfg80211 peer measurement capabilities
5165  * @max_peers: maximum number of peers in a single measurement
5166  * @report_ap_tsf: can report assoc AP's TSF for radio resource measurement
5167  * @randomize_mac_addr: can randomize MAC address for measurement
5168  * @ftm: FTM measurement data
5169  * @ftm.supported: FTM measurement is supported
5170  * @ftm.asap: ASAP-mode is supported
5171  * @ftm.non_asap: non-ASAP-mode is supported
5172  * @ftm.request_lci: can request LCI data
5173  * @ftm.request_civicloc: can request civic location data
5174  * @ftm.preambles: bitmap of preambles supported (&enum nl80211_preamble)
5175  * @ftm.bandwidths: bitmap of bandwidths supported (&enum nl80211_chan_width)
5176  * @ftm.max_bursts_exponent: maximum burst exponent supported
5177  *	(set to -1 if not limited; note that setting this will necessarily
5178  *	forbid using the value 15 to let the responder pick)
5179  * @ftm.max_ftms_per_burst: maximum FTMs per burst supported (set to 0 if
5180  *	not limited)
5181  * @ftm.trigger_based: trigger based ranging measurement is supported
5182  * @ftm.non_trigger_based: non trigger based ranging measurement is supported
5183  */
5184 struct cfg80211_pmsr_capabilities {
5185 	unsigned int max_peers;
5186 	u8 report_ap_tsf:1,
5187 	   randomize_mac_addr:1;
5188 
5189 	struct {
5190 		u32 preambles;
5191 		u32 bandwidths;
5192 		s8 max_bursts_exponent;
5193 		u8 max_ftms_per_burst;
5194 		u8 supported:1,
5195 		   asap:1,
5196 		   non_asap:1,
5197 		   request_lci:1,
5198 		   request_civicloc:1,
5199 		   trigger_based:1,
5200 		   non_trigger_based:1;
5201 	} ftm;
5202 };
5203 
5204 /**
5205  * struct wiphy_iftype_akm_suites - This structure encapsulates supported akm
5206  * suites for interface types defined in @iftypes_mask. Each type in the
5207  * @iftypes_mask must be unique across all instances of iftype_akm_suites.
5208  *
5209  * @iftypes_mask: bitmask of interfaces types
5210  * @akm_suites: points to an array of supported akm suites
5211  * @n_akm_suites: number of supported AKM suites
5212  */
5213 struct wiphy_iftype_akm_suites {
5214 	u16 iftypes_mask;
5215 	const u32 *akm_suites;
5216 	int n_akm_suites;
5217 };
5218 
5219 #define CFG80211_HW_TIMESTAMP_ALL_PEERS	0xffff
5220 
5221 /**
5222  * struct wiphy - wireless hardware description
5223  * @mtx: mutex for the data (structures) of this device
5224  * @reg_notifier: the driver's regulatory notification callback,
5225  *	note that if your driver uses wiphy_apply_custom_regulatory()
5226  *	the reg_notifier's request can be passed as NULL
5227  * @regd: the driver's regulatory domain, if one was requested via
5228  *	the regulatory_hint() API. This can be used by the driver
5229  *	on the reg_notifier() if it chooses to ignore future
5230  *	regulatory domain changes caused by other drivers.
5231  * @signal_type: signal type reported in &struct cfg80211_bss.
5232  * @cipher_suites: supported cipher suites
5233  * @n_cipher_suites: number of supported cipher suites
5234  * @akm_suites: supported AKM suites. These are the default AKMs supported if
5235  *	the supported AKMs not advertized for a specific interface type in
5236  *	iftype_akm_suites.
5237  * @n_akm_suites: number of supported AKM suites
5238  * @iftype_akm_suites: array of supported akm suites info per interface type.
5239  *	Note that the bits in @iftypes_mask inside this structure cannot
5240  *	overlap (i.e. only one occurrence of each type is allowed across all
5241  *	instances of iftype_akm_suites).
5242  * @num_iftype_akm_suites: number of interface types for which supported akm
5243  *	suites are specified separately.
5244  * @retry_short: Retry limit for short frames (dot11ShortRetryLimit)
5245  * @retry_long: Retry limit for long frames (dot11LongRetryLimit)
5246  * @frag_threshold: Fragmentation threshold (dot11FragmentationThreshold);
5247  *	-1 = fragmentation disabled, only odd values >= 256 used
5248  * @rts_threshold: RTS threshold (dot11RTSThreshold); -1 = RTS/CTS disabled
5249  * @_net: the network namespace this wiphy currently lives in
5250  * @perm_addr: permanent MAC address of this device
5251  * @addr_mask: If the device supports multiple MAC addresses by masking,
5252  *	set this to a mask with variable bits set to 1, e.g. if the last
5253  *	four bits are variable then set it to 00-00-00-00-00-0f. The actual
5254  *	variable bits shall be determined by the interfaces added, with
5255  *	interfaces not matching the mask being rejected to be brought up.
5256  * @n_addresses: number of addresses in @addresses.
5257  * @addresses: If the device has more than one address, set this pointer
5258  *	to a list of addresses (6 bytes each). The first one will be used
5259  *	by default for perm_addr. In this case, the mask should be set to
5260  *	all-zeroes. In this case it is assumed that the device can handle
5261  *	the same number of arbitrary MAC addresses.
5262  * @registered: protects ->resume and ->suspend sysfs callbacks against
5263  *	unregister hardware
5264  * @debugfsdir: debugfs directory used for this wiphy (ieee80211/<wiphyname>).
5265  *	It will be renamed automatically on wiphy renames
5266  * @dev: (virtual) struct device for this wiphy. The item in
5267  *	/sys/class/ieee80211/ points to this. You need use set_wiphy_dev()
5268  *	(see below).
5269  * @wext: wireless extension handlers
5270  * @priv: driver private data (sized according to wiphy_new() parameter)
5271  * @interface_modes: bitmask of interfaces types valid for this wiphy,
5272  *	must be set by driver
5273  * @iface_combinations: Valid interface combinations array, should not
5274  *	list single interface types.
5275  * @n_iface_combinations: number of entries in @iface_combinations array.
5276  * @software_iftypes: bitmask of software interface types, these are not
5277  *	subject to any restrictions since they are purely managed in SW.
5278  * @flags: wiphy flags, see &enum wiphy_flags
5279  * @regulatory_flags: wiphy regulatory flags, see
5280  *	&enum ieee80211_regulatory_flags
5281  * @features: features advertised to nl80211, see &enum nl80211_feature_flags.
5282  * @ext_features: extended features advertised to nl80211, see
5283  *	&enum nl80211_ext_feature_index.
5284  * @bss_priv_size: each BSS struct has private data allocated with it,
5285  *	this variable determines its size
5286  * @max_scan_ssids: maximum number of SSIDs the device can scan for in
5287  *	any given scan
5288  * @max_sched_scan_reqs: maximum number of scheduled scan requests that
5289  *	the device can run concurrently.
5290  * @max_sched_scan_ssids: maximum number of SSIDs the device can scan
5291  *	for in any given scheduled scan
5292  * @max_match_sets: maximum number of match sets the device can handle
5293  *	when performing a scheduled scan, 0 if filtering is not
5294  *	supported.
5295  * @max_scan_ie_len: maximum length of user-controlled IEs device can
5296  *	add to probe request frames transmitted during a scan, must not
5297  *	include fixed IEs like supported rates
5298  * @max_sched_scan_ie_len: same as max_scan_ie_len, but for scheduled
5299  *	scans
5300  * @max_sched_scan_plans: maximum number of scan plans (scan interval and number
5301  *	of iterations) for scheduled scan supported by the device.
5302  * @max_sched_scan_plan_interval: maximum interval (in seconds) for a
5303  *	single scan plan supported by the device.
5304  * @max_sched_scan_plan_iterations: maximum number of iterations for a single
5305  *	scan plan supported by the device.
5306  * @coverage_class: current coverage class
5307  * @fw_version: firmware version for ethtool reporting
5308  * @hw_version: hardware version for ethtool reporting
5309  * @max_num_pmkids: maximum number of PMKIDs supported by device
5310  * @privid: a pointer that drivers can use to identify if an arbitrary
5311  *	wiphy is theirs, e.g. in global notifiers
5312  * @bands: information about bands/channels supported by this device
5313  *
5314  * @mgmt_stypes: bitmasks of frame subtypes that can be subscribed to or
5315  *	transmitted through nl80211, points to an array indexed by interface
5316  *	type
5317  *
5318  * @available_antennas_tx: bitmap of antennas which are available to be
5319  *	configured as TX antennas. Antenna configuration commands will be
5320  *	rejected unless this or @available_antennas_rx is set.
5321  *
5322  * @available_antennas_rx: bitmap of antennas which are available to be
5323  *	configured as RX antennas. Antenna configuration commands will be
5324  *	rejected unless this or @available_antennas_tx is set.
5325  *
5326  * @probe_resp_offload:
5327  *	 Bitmap of supported protocols for probe response offloading.
5328  *	 See &enum nl80211_probe_resp_offload_support_attr. Only valid
5329  *	 when the wiphy flag @WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD is set.
5330  *
5331  * @max_remain_on_channel_duration: Maximum time a remain-on-channel operation
5332  *	may request, if implemented.
5333  *
5334  * @wowlan: WoWLAN support information
5335  * @wowlan_config: current WoWLAN configuration; this should usually not be
5336  *	used since access to it is necessarily racy, use the parameter passed
5337  *	to the suspend() operation instead.
5338  *
5339  * @ap_sme_capa: AP SME capabilities, flags from &enum nl80211_ap_sme_features.
5340  * @ht_capa_mod_mask:  Specify what ht_cap values can be over-ridden.
5341  *	If null, then none can be over-ridden.
5342  * @vht_capa_mod_mask:  Specify what VHT capabilities can be over-ridden.
5343  *	If null, then none can be over-ridden.
5344  *
5345  * @wdev_list: the list of associated (virtual) interfaces; this list must
5346  *	not be modified by the driver, but can be read with RTNL/RCU protection.
5347  *
5348  * @max_acl_mac_addrs: Maximum number of MAC addresses that the device
5349  *	supports for ACL.
5350  *
5351  * @extended_capabilities: extended capabilities supported by the driver,
5352  *	additional capabilities might be supported by userspace; these are
5353  *	the 802.11 extended capabilities ("Extended Capabilities element")
5354  *	and are in the same format as in the information element. See
5355  *	802.11-2012 8.4.2.29 for the defined fields. These are the default
5356  *	extended capabilities to be used if the capabilities are not specified
5357  *	for a specific interface type in iftype_ext_capab.
5358  * @extended_capabilities_mask: mask of the valid values
5359  * @extended_capabilities_len: length of the extended capabilities
5360  * @iftype_ext_capab: array of extended capabilities per interface type
5361  * @num_iftype_ext_capab: number of interface types for which extended
5362  *	capabilities are specified separately.
5363  * @coalesce: packet coalescing support information
5364  *
5365  * @vendor_commands: array of vendor commands supported by the hardware
5366  * @n_vendor_commands: number of vendor commands
5367  * @vendor_events: array of vendor events supported by the hardware
5368  * @n_vendor_events: number of vendor events
5369  *
5370  * @max_ap_assoc_sta: maximum number of associated stations supported in AP mode
5371  *	(including P2P GO) or 0 to indicate no such limit is advertised. The
5372  *	driver is allowed to advertise a theoretical limit that it can reach in
5373  *	some cases, but may not always reach.
5374  *
5375  * @max_num_csa_counters: Number of supported csa_counters in beacons
5376  *	and probe responses.  This value should be set if the driver
5377  *	wishes to limit the number of csa counters. Default (0) means
5378  *	infinite.
5379  * @bss_select_support: bitmask indicating the BSS selection criteria supported
5380  *	by the driver in the .connect() callback. The bit position maps to the
5381  *	attribute indices defined in &enum nl80211_bss_select_attr.
5382  *
5383  * @nan_supported_bands: bands supported by the device in NAN mode, a
5384  *	bitmap of &enum nl80211_band values.  For instance, for
5385  *	NL80211_BAND_2GHZ, bit 0 would be set
5386  *	(i.e. BIT(NL80211_BAND_2GHZ)).
5387  *
5388  * @txq_limit: configuration of internal TX queue frame limit
5389  * @txq_memory_limit: configuration internal TX queue memory limit
5390  * @txq_quantum: configuration of internal TX queue scheduler quantum
5391  *
5392  * @tx_queue_len: allow setting transmit queue len for drivers not using
5393  *	wake_tx_queue
5394  *
5395  * @support_mbssid: can HW support association with nontransmitted AP
5396  * @support_only_he_mbssid: don't parse MBSSID elements if it is not
5397  *	HE AP, in order to avoid compatibility issues.
5398  *	@support_mbssid must be set for this to have any effect.
5399  *
5400  * @pmsr_capa: peer measurement capabilities
5401  *
5402  * @tid_config_support: describes the per-TID config support that the
5403  *	device has
5404  * @tid_config_support.vif: bitmap of attributes (configurations)
5405  *	supported by the driver for each vif
5406  * @tid_config_support.peer: bitmap of attributes (configurations)
5407  *	supported by the driver for each peer
5408  * @tid_config_support.max_retry: maximum supported retry count for
5409  *	long/short retry configuration
5410  *
5411  * @max_data_retry_count: maximum supported per TID retry count for
5412  *	configuration through the %NL80211_TID_CONFIG_ATTR_RETRY_SHORT and
5413  *	%NL80211_TID_CONFIG_ATTR_RETRY_LONG attributes
5414  * @sar_capa: SAR control capabilities
5415  * @rfkill: a pointer to the rfkill structure
5416  *
5417  * @mbssid_max_interfaces: maximum number of interfaces supported by the driver
5418  *	in a multiple BSSID set. This field must be set to a non-zero value
5419  *	by the driver to advertise MBSSID support.
5420  * @ema_max_profile_periodicity: maximum profile periodicity supported by
5421  *	the driver. Setting this field to a non-zero value indicates that the
5422  *	driver supports enhanced multi-BSSID advertisements (EMA AP).
5423  * @max_num_akm_suites: maximum number of AKM suites allowed for
5424  *	configuration through %NL80211_CMD_CONNECT, %NL80211_CMD_ASSOCIATE and
5425  *	%NL80211_CMD_START_AP. Set to NL80211_MAX_NR_AKM_SUITES if not set by
5426  *	driver. If set by driver minimum allowed value is
5427  *	NL80211_MAX_NR_AKM_SUITES in order to avoid compatibility issues with
5428  *	legacy userspace and maximum allowed value is
5429  *	CFG80211_MAX_NUM_AKM_SUITES.
5430  *
5431  * @hw_timestamp_max_peers: maximum number of peers that the driver supports
5432  *	enabling HW timestamping for concurrently. Setting this field to a
5433  *	non-zero value indicates that the driver supports HW timestamping.
5434  *	A value of %CFG80211_HW_TIMESTAMP_ALL_PEERS indicates the driver
5435  *	supports enabling HW timestamping for all peers (i.e. no need to
5436  *	specify a mac address).
5437  */
5438 struct wiphy {
5439 	struct mutex mtx;
5440 
5441 	/* assign these fields before you register the wiphy */
5442 
5443 	u8 perm_addr[ETH_ALEN];
5444 	u8 addr_mask[ETH_ALEN];
5445 
5446 	struct mac_address *addresses;
5447 
5448 	const struct ieee80211_txrx_stypes *mgmt_stypes;
5449 
5450 	const struct ieee80211_iface_combination *iface_combinations;
5451 	int n_iface_combinations;
5452 	u16 software_iftypes;
5453 
5454 	u16 n_addresses;
5455 
5456 	/* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */
5457 	u16 interface_modes;
5458 
5459 	u16 max_acl_mac_addrs;
5460 
5461 	u32 flags, regulatory_flags, features;
5462 	u8 ext_features[DIV_ROUND_UP(NUM_NL80211_EXT_FEATURES, 8)];
5463 
5464 	u32 ap_sme_capa;
5465 
5466 	enum cfg80211_signal_type signal_type;
5467 
5468 	int bss_priv_size;
5469 	u8 max_scan_ssids;
5470 	u8 max_sched_scan_reqs;
5471 	u8 max_sched_scan_ssids;
5472 	u8 max_match_sets;
5473 	u16 max_scan_ie_len;
5474 	u16 max_sched_scan_ie_len;
5475 	u32 max_sched_scan_plans;
5476 	u32 max_sched_scan_plan_interval;
5477 	u32 max_sched_scan_plan_iterations;
5478 
5479 	int n_cipher_suites;
5480 	const u32 *cipher_suites;
5481 
5482 	int n_akm_suites;
5483 	const u32 *akm_suites;
5484 
5485 	const struct wiphy_iftype_akm_suites *iftype_akm_suites;
5486 	unsigned int num_iftype_akm_suites;
5487 
5488 	u8 retry_short;
5489 	u8 retry_long;
5490 	u32 frag_threshold;
5491 	u32 rts_threshold;
5492 	u8 coverage_class;
5493 
5494 	char fw_version[ETHTOOL_FWVERS_LEN];
5495 	u32 hw_version;
5496 
5497 #ifdef CONFIG_PM
5498 	const struct wiphy_wowlan_support *wowlan;
5499 	struct cfg80211_wowlan *wowlan_config;
5500 #endif
5501 
5502 	u16 max_remain_on_channel_duration;
5503 
5504 	u8 max_num_pmkids;
5505 
5506 	u32 available_antennas_tx;
5507 	u32 available_antennas_rx;
5508 
5509 	u32 probe_resp_offload;
5510 
5511 	const u8 *extended_capabilities, *extended_capabilities_mask;
5512 	u8 extended_capabilities_len;
5513 
5514 	const struct wiphy_iftype_ext_capab *iftype_ext_capab;
5515 	unsigned int num_iftype_ext_capab;
5516 
5517 	const void *privid;
5518 
5519 	struct ieee80211_supported_band *bands[NUM_NL80211_BANDS];
5520 
5521 	void (*reg_notifier)(struct wiphy *wiphy,
5522 			     struct regulatory_request *request);
5523 
5524 	/* fields below are read-only, assigned by cfg80211 */
5525 
5526 	const struct ieee80211_regdomain __rcu *regd;
5527 
5528 	struct device dev;
5529 
5530 	bool registered;
5531 
5532 	struct dentry *debugfsdir;
5533 
5534 	const struct ieee80211_ht_cap *ht_capa_mod_mask;
5535 	const struct ieee80211_vht_cap *vht_capa_mod_mask;
5536 
5537 	struct list_head wdev_list;
5538 
5539 	possible_net_t _net;
5540 
5541 #ifdef CONFIG_CFG80211_WEXT
5542 	const struct iw_handler_def *wext;
5543 #endif
5544 
5545 	const struct wiphy_coalesce_support *coalesce;
5546 
5547 	const struct wiphy_vendor_command *vendor_commands;
5548 	const struct nl80211_vendor_cmd_info *vendor_events;
5549 	int n_vendor_commands, n_vendor_events;
5550 
5551 	u16 max_ap_assoc_sta;
5552 
5553 	u8 max_num_csa_counters;
5554 
5555 	u32 bss_select_support;
5556 
5557 	u8 nan_supported_bands;
5558 
5559 	u32 txq_limit;
5560 	u32 txq_memory_limit;
5561 	u32 txq_quantum;
5562 
5563 	unsigned long tx_queue_len;
5564 
5565 	u8 support_mbssid:1,
5566 	   support_only_he_mbssid:1;
5567 
5568 	const struct cfg80211_pmsr_capabilities *pmsr_capa;
5569 
5570 	struct {
5571 		u64 peer, vif;
5572 		u8 max_retry;
5573 	} tid_config_support;
5574 
5575 	u8 max_data_retry_count;
5576 
5577 	const struct cfg80211_sar_capa *sar_capa;
5578 
5579 	struct rfkill *rfkill;
5580 
5581 	u8 mbssid_max_interfaces;
5582 	u8 ema_max_profile_periodicity;
5583 	u16 max_num_akm_suites;
5584 
5585 	u16 hw_timestamp_max_peers;
5586 
5587 	char priv[] __aligned(NETDEV_ALIGN);
5588 };
5589 
wiphy_net(struct wiphy * wiphy)5590 static inline struct net *wiphy_net(struct wiphy *wiphy)
5591 {
5592 	return read_pnet(&wiphy->_net);
5593 }
5594 
wiphy_net_set(struct wiphy * wiphy,struct net * net)5595 static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net)
5596 {
5597 	write_pnet(&wiphy->_net, net);
5598 }
5599 
5600 /**
5601  * wiphy_priv - return priv from wiphy
5602  *
5603  * @wiphy: the wiphy whose priv pointer to return
5604  * Return: The priv of @wiphy.
5605  */
wiphy_priv(struct wiphy * wiphy)5606 static inline void *wiphy_priv(struct wiphy *wiphy)
5607 {
5608 	BUG_ON(!wiphy);
5609 	return &wiphy->priv;
5610 }
5611 
5612 /**
5613  * priv_to_wiphy - return the wiphy containing the priv
5614  *
5615  * @priv: a pointer previously returned by wiphy_priv
5616  * Return: The wiphy of @priv.
5617  */
priv_to_wiphy(void * priv)5618 static inline struct wiphy *priv_to_wiphy(void *priv)
5619 {
5620 	BUG_ON(!priv);
5621 	return container_of(priv, struct wiphy, priv);
5622 }
5623 
5624 /**
5625  * set_wiphy_dev - set device pointer for wiphy
5626  *
5627  * @wiphy: The wiphy whose device to bind
5628  * @dev: The device to parent it to
5629  */
set_wiphy_dev(struct wiphy * wiphy,struct device * dev)5630 static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev)
5631 {
5632 	wiphy->dev.parent = dev;
5633 }
5634 
5635 /**
5636  * wiphy_dev - get wiphy dev pointer
5637  *
5638  * @wiphy: The wiphy whose device struct to look up
5639  * Return: The dev of @wiphy.
5640  */
wiphy_dev(struct wiphy * wiphy)5641 static inline struct device *wiphy_dev(struct wiphy *wiphy)
5642 {
5643 	return wiphy->dev.parent;
5644 }
5645 
5646 /**
5647  * wiphy_name - get wiphy name
5648  *
5649  * @wiphy: The wiphy whose name to return
5650  * Return: The name of @wiphy.
5651  */
wiphy_name(const struct wiphy * wiphy)5652 static inline const char *wiphy_name(const struct wiphy *wiphy)
5653 {
5654 	return dev_name(&wiphy->dev);
5655 }
5656 
5657 /**
5658  * wiphy_new_nm - create a new wiphy for use with cfg80211
5659  *
5660  * @ops: The configuration operations for this device
5661  * @sizeof_priv: The size of the private area to allocate
5662  * @requested_name: Request a particular name.
5663  *	NULL is valid value, and means use the default phy%d naming.
5664  *
5665  * Create a new wiphy and associate the given operations with it.
5666  * @sizeof_priv bytes are allocated for private use.
5667  *
5668  * Return: A pointer to the new wiphy. This pointer must be
5669  * assigned to each netdev's ieee80211_ptr for proper operation.
5670  */
5671 struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
5672 			   const char *requested_name);
5673 
5674 /**
5675  * wiphy_new - create a new wiphy for use with cfg80211
5676  *
5677  * @ops: The configuration operations for this device
5678  * @sizeof_priv: The size of the private area to allocate
5679  *
5680  * Create a new wiphy and associate the given operations with it.
5681  * @sizeof_priv bytes are allocated for private use.
5682  *
5683  * Return: A pointer to the new wiphy. This pointer must be
5684  * assigned to each netdev's ieee80211_ptr for proper operation.
5685  */
wiphy_new(const struct cfg80211_ops * ops,int sizeof_priv)5686 static inline struct wiphy *wiphy_new(const struct cfg80211_ops *ops,
5687 				      int sizeof_priv)
5688 {
5689 	return wiphy_new_nm(ops, sizeof_priv, NULL);
5690 }
5691 
5692 /**
5693  * wiphy_register - register a wiphy with cfg80211
5694  *
5695  * @wiphy: The wiphy to register.
5696  *
5697  * Return: A non-negative wiphy index or a negative error code.
5698  */
5699 int wiphy_register(struct wiphy *wiphy);
5700 
5701 /* this is a define for better error reporting (file/line) */
5702 #define lockdep_assert_wiphy(wiphy) lockdep_assert_held(&(wiphy)->mtx)
5703 
5704 /**
5705  * rcu_dereference_wiphy - rcu_dereference with debug checking
5706  * @wiphy: the wiphy to check the locking on
5707  * @p: The pointer to read, prior to dereferencing
5708  *
5709  * Do an rcu_dereference(p), but check caller either holds rcu_read_lock()
5710  * or RTNL. Note: Please prefer wiphy_dereference() or rcu_dereference().
5711  */
5712 #define rcu_dereference_wiphy(wiphy, p)				\
5713         rcu_dereference_check(p, lockdep_is_held(&wiphy->mtx))
5714 
5715 /**
5716  * wiphy_dereference - fetch RCU pointer when updates are prevented by wiphy mtx
5717  * @wiphy: the wiphy to check the locking on
5718  * @p: The pointer to read, prior to dereferencing
5719  *
5720  * Return the value of the specified RCU-protected pointer, but omit the
5721  * READ_ONCE(), because caller holds the wiphy mutex used for updates.
5722  */
5723 #define wiphy_dereference(wiphy, p)				\
5724         rcu_dereference_protected(p, lockdep_is_held(&wiphy->mtx))
5725 
5726 /**
5727  * get_wiphy_regdom - get custom regdomain for the given wiphy
5728  * @wiphy: the wiphy to get the regdomain from
5729  */
5730 const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy);
5731 
5732 /**
5733  * wiphy_unregister - deregister a wiphy from cfg80211
5734  *
5735  * @wiphy: The wiphy to unregister.
5736  *
5737  * After this call, no more requests can be made with this priv
5738  * pointer, but the call may sleep to wait for an outstanding
5739  * request that is being handled.
5740  */
5741 void wiphy_unregister(struct wiphy *wiphy);
5742 
5743 /**
5744  * wiphy_free - free wiphy
5745  *
5746  * @wiphy: The wiphy to free
5747  */
5748 void wiphy_free(struct wiphy *wiphy);
5749 
5750 /* internal structs */
5751 struct cfg80211_conn;
5752 struct cfg80211_internal_bss;
5753 struct cfg80211_cached_keys;
5754 struct cfg80211_cqm_config;
5755 
5756 /**
5757  * wiphy_lock - lock the wiphy
5758  * @wiphy: the wiphy to lock
5759  *
5760  * This is needed around registering and unregistering netdevs that
5761  * aren't created through cfg80211 calls, since that requires locking
5762  * in cfg80211 when the notifiers is called, but that cannot
5763  * differentiate which way it's called.
5764  *
5765  * It can also be used by drivers for their own purposes.
5766  *
5767  * When cfg80211 ops are called, the wiphy is already locked.
5768  *
5769  * Note that this makes sure that no workers that have been queued
5770  * with wiphy_queue_work() are running.
5771  */
wiphy_lock(struct wiphy * wiphy)5772 static inline void wiphy_lock(struct wiphy *wiphy)
5773 	__acquires(&wiphy->mtx)
5774 {
5775 	mutex_lock(&wiphy->mtx);
5776 	__acquire(&wiphy->mtx);
5777 }
5778 
5779 /**
5780  * wiphy_unlock - unlock the wiphy again
5781  * @wiphy: the wiphy to unlock
5782  */
wiphy_unlock(struct wiphy * wiphy)5783 static inline void wiphy_unlock(struct wiphy *wiphy)
5784 	__releases(&wiphy->mtx)
5785 {
5786 	__release(&wiphy->mtx);
5787 	mutex_unlock(&wiphy->mtx);
5788 }
5789 
5790 struct wiphy_work;
5791 typedef void (*wiphy_work_func_t)(struct wiphy *, struct wiphy_work *);
5792 
5793 struct wiphy_work {
5794 	struct list_head entry;
5795 	wiphy_work_func_t func;
5796 };
5797 
wiphy_work_init(struct wiphy_work * work,wiphy_work_func_t func)5798 static inline void wiphy_work_init(struct wiphy_work *work,
5799 				   wiphy_work_func_t func)
5800 {
5801 	INIT_LIST_HEAD(&work->entry);
5802 	work->func = func;
5803 }
5804 
5805 /**
5806  * wiphy_work_queue - queue work for the wiphy
5807  * @wiphy: the wiphy to queue for
5808  * @work: the work item
5809  *
5810  * This is useful for work that must be done asynchronously, and work
5811  * queued here has the special property that the wiphy mutex will be
5812  * held as if wiphy_lock() was called, and that it cannot be running
5813  * after wiphy_lock() was called. Therefore, wiphy_cancel_work() can
5814  * use just cancel_work() instead of cancel_work_sync(), it requires
5815  * being in a section protected by wiphy_lock().
5816  */
5817 void wiphy_work_queue(struct wiphy *wiphy, struct wiphy_work *work);
5818 
5819 /**
5820  * wiphy_work_cancel - cancel previously queued work
5821  * @wiphy: the wiphy, for debug purposes
5822  * @work: the work to cancel
5823  *
5824  * Cancel the work *without* waiting for it, this assumes being
5825  * called under the wiphy mutex acquired by wiphy_lock().
5826  */
5827 void wiphy_work_cancel(struct wiphy *wiphy, struct wiphy_work *work);
5828 
5829 /**
5830  * wiphy_work_flush - flush previously queued work
5831  * @wiphy: the wiphy, for debug purposes
5832  * @work: the work to flush, this can be %NULL to flush all work
5833  *
5834  * Flush the work (i.e. run it if pending). This must be called
5835  * under the wiphy mutex acquired by wiphy_lock().
5836  */
5837 void wiphy_work_flush(struct wiphy *wiphy, struct wiphy_work *work);
5838 
5839 struct wiphy_delayed_work {
5840 	struct wiphy_work work;
5841 	struct wiphy *wiphy;
5842 	struct timer_list timer;
5843 };
5844 
5845 void wiphy_delayed_work_timer(struct timer_list *t);
5846 
wiphy_delayed_work_init(struct wiphy_delayed_work * dwork,wiphy_work_func_t func)5847 static inline void wiphy_delayed_work_init(struct wiphy_delayed_work *dwork,
5848 					   wiphy_work_func_t func)
5849 {
5850 	timer_setup(&dwork->timer, wiphy_delayed_work_timer, 0);
5851 	wiphy_work_init(&dwork->work, func);
5852 }
5853 
5854 /**
5855  * wiphy_delayed_work_queue - queue delayed work for the wiphy
5856  * @wiphy: the wiphy to queue for
5857  * @dwork: the delayable worker
5858  * @delay: number of jiffies to wait before queueing
5859  *
5860  * This is useful for work that must be done asynchronously, and work
5861  * queued here has the special property that the wiphy mutex will be
5862  * held as if wiphy_lock() was called, and that it cannot be running
5863  * after wiphy_lock() was called. Therefore, wiphy_cancel_work() can
5864  * use just cancel_work() instead of cancel_work_sync(), it requires
5865  * being in a section protected by wiphy_lock().
5866  */
5867 void wiphy_delayed_work_queue(struct wiphy *wiphy,
5868 			      struct wiphy_delayed_work *dwork,
5869 			      unsigned long delay);
5870 
5871 /**
5872  * wiphy_delayed_work_cancel - cancel previously queued delayed work
5873  * @wiphy: the wiphy, for debug purposes
5874  * @dwork: the delayed work to cancel
5875  *
5876  * Cancel the work *without* waiting for it, this assumes being
5877  * called under the wiphy mutex acquired by wiphy_lock().
5878  */
5879 void wiphy_delayed_work_cancel(struct wiphy *wiphy,
5880 			       struct wiphy_delayed_work *dwork);
5881 
5882 /**
5883  * wiphy_delayed_work_flush - flush previously queued delayed work
5884  * @wiphy: the wiphy, for debug purposes
5885  * @work: the work to flush
5886  *
5887  * Flush the work (i.e. run it if pending). This must be called
5888  * under the wiphy mutex acquired by wiphy_lock().
5889  */
5890 void wiphy_delayed_work_flush(struct wiphy *wiphy,
5891 			      struct wiphy_delayed_work *dwork);
5892 
5893 /**
5894  * struct wireless_dev - wireless device state
5895  *
5896  * For netdevs, this structure must be allocated by the driver
5897  * that uses the ieee80211_ptr field in struct net_device (this
5898  * is intentional so it can be allocated along with the netdev.)
5899  * It need not be registered then as netdev registration will
5900  * be intercepted by cfg80211 to see the new wireless device,
5901  * however, drivers must lock the wiphy before registering or
5902  * unregistering netdevs if they pre-create any netdevs (in ops
5903  * called from cfg80211, the wiphy is already locked.)
5904  *
5905  * For non-netdev uses, it must also be allocated by the driver
5906  * in response to the cfg80211 callbacks that require it, as
5907  * there's no netdev registration in that case it may not be
5908  * allocated outside of callback operations that return it.
5909  *
5910  * @wiphy: pointer to hardware description
5911  * @iftype: interface type
5912  * @registered: is this wdev already registered with cfg80211
5913  * @registering: indicates we're doing registration under wiphy lock
5914  *	for the notifier
5915  * @list: (private) Used to collect the interfaces
5916  * @netdev: (private) Used to reference back to the netdev, may be %NULL
5917  * @identifier: (private) Identifier used in nl80211 to identify this
5918  *	wireless device if it has no netdev
5919  * @u: union containing data specific to @iftype
5920  * @connected: indicates if connected or not (STA mode)
5921  * @bssid: (private) Used by the internal configuration code
5922  * @wext: (private) Used by the internal wireless extensions compat code
5923  * @wext.ibss: (private) IBSS data part of wext handling
5924  * @wext.connect: (private) connection handling data
5925  * @wext.keys: (private) (WEP) key data
5926  * @wext.ie: (private) extra elements for association
5927  * @wext.ie_len: (private) length of extra elements
5928  * @wext.bssid: (private) selected network BSSID
5929  * @wext.ssid: (private) selected network SSID
5930  * @wext.default_key: (private) selected default key index
5931  * @wext.default_mgmt_key: (private) selected default management key index
5932  * @wext.prev_bssid: (private) previous BSSID for reassociation
5933  * @wext.prev_bssid_valid: (private) previous BSSID validity
5934  * @use_4addr: indicates 4addr mode is used on this interface, must be
5935  *	set by driver (if supported) on add_interface BEFORE registering the
5936  *	netdev and may otherwise be used by driver read-only, will be update
5937  *	by cfg80211 on change_interface
5938  * @mgmt_registrations: list of registrations for management frames
5939  * @mgmt_registrations_need_update: mgmt registrations were updated,
5940  *	need to propagate the update to the driver
5941  * @mtx: mutex used to lock data in this struct, may be used by drivers
5942  *	and some API functions require it held
5943  * @beacon_interval: beacon interval used on this device for transmitting
5944  *	beacons, 0 when not valid
5945  * @address: The address for this device, valid only if @netdev is %NULL
5946  * @is_running: true if this is a non-netdev device that has been started, e.g.
5947  *	the P2P Device.
5948  * @cac_started: true if DFS channel availability check has been started
5949  * @cac_start_time: timestamp (jiffies) when the dfs state was entered.
5950  * @cac_time_ms: CAC time in ms
5951  * @ps: powersave mode is enabled
5952  * @ps_timeout: dynamic powersave timeout
5953  * @ap_unexpected_nlportid: (private) netlink port ID of application
5954  *	registered for unexpected class 3 frames (AP mode)
5955  * @conn: (private) cfg80211 software SME connection state machine data
5956  * @connect_keys: (private) keys to set after connection is established
5957  * @conn_bss_type: connecting/connected BSS type
5958  * @conn_owner_nlportid: (private) connection owner socket port ID
5959  * @disconnect_wk: (private) auto-disconnect work
5960  * @disconnect_bssid: (private) the BSSID to use for auto-disconnect
5961  * @event_list: (private) list for internal event processing
5962  * @event_lock: (private) lock for event list
5963  * @owner_nlportid: (private) owner socket port ID
5964  * @nl_owner_dead: (private) owner socket went away
5965  * @cqm_rssi_work: (private) CQM RSSI reporting work
5966  * @cqm_config: (private) nl80211 RSSI monitor state
5967  * @pmsr_list: (private) peer measurement requests
5968  * @pmsr_lock: (private) peer measurements requests/results lock
5969  * @pmsr_free_wk: (private) peer measurements cleanup work
5970  * @unprot_beacon_reported: (private) timestamp of last
5971  *	unprotected beacon report
5972  * @links: array of %IEEE80211_MLD_MAX_NUM_LINKS elements containing @addr
5973  *	@ap and @client for each link
5974  * @valid_links: bitmap describing what elements of @links are valid
5975  */
5976 struct wireless_dev {
5977 	struct wiphy *wiphy;
5978 	enum nl80211_iftype iftype;
5979 
5980 	/* the remainder of this struct should be private to cfg80211 */
5981 	struct list_head list;
5982 	struct net_device *netdev;
5983 
5984 	u32 identifier;
5985 
5986 	struct list_head mgmt_registrations;
5987 	u8 mgmt_registrations_need_update:1;
5988 
5989 	struct mutex mtx;
5990 
5991 	bool use_4addr, is_running, registered, registering;
5992 
5993 	u8 address[ETH_ALEN] __aligned(sizeof(u16));
5994 
5995 	/* currently used for IBSS and SME - might be rearranged later */
5996 	struct cfg80211_conn *conn;
5997 	struct cfg80211_cached_keys *connect_keys;
5998 	enum ieee80211_bss_type conn_bss_type;
5999 	u32 conn_owner_nlportid;
6000 
6001 	struct work_struct disconnect_wk;
6002 	u8 disconnect_bssid[ETH_ALEN];
6003 
6004 	struct list_head event_list;
6005 	spinlock_t event_lock;
6006 
6007 	u8 connected:1;
6008 
6009 	bool ps;
6010 	int ps_timeout;
6011 
6012 	u32 ap_unexpected_nlportid;
6013 
6014 	u32 owner_nlportid;
6015 	bool nl_owner_dead;
6016 
6017 	/* FIXME: need to rework radar detection for MLO */
6018 	bool cac_started;
6019 	unsigned long cac_start_time;
6020 	unsigned int cac_time_ms;
6021 
6022 #ifdef CONFIG_CFG80211_WEXT
6023 	/* wext data */
6024 	struct {
6025 		struct cfg80211_ibss_params ibss;
6026 		struct cfg80211_connect_params connect;
6027 		struct cfg80211_cached_keys *keys;
6028 		const u8 *ie;
6029 		size_t ie_len;
6030 		u8 bssid[ETH_ALEN];
6031 		u8 prev_bssid[ETH_ALEN];
6032 		u8 ssid[IEEE80211_MAX_SSID_LEN];
6033 		s8 default_key, default_mgmt_key;
6034 		bool prev_bssid_valid;
6035 	} wext;
6036 #endif
6037 
6038 	struct wiphy_work cqm_rssi_work;
6039 	struct cfg80211_cqm_config __rcu *cqm_config;
6040 
6041 	struct list_head pmsr_list;
6042 	spinlock_t pmsr_lock;
6043 	struct work_struct pmsr_free_wk;
6044 
6045 	unsigned long unprot_beacon_reported;
6046 
6047 	union {
6048 		struct {
6049 			u8 connected_addr[ETH_ALEN] __aligned(2);
6050 			u8 ssid[IEEE80211_MAX_SSID_LEN];
6051 			u8 ssid_len;
6052 		} client;
6053 		struct {
6054 			int beacon_interval;
6055 			struct cfg80211_chan_def preset_chandef;
6056 			struct cfg80211_chan_def chandef;
6057 			u8 id[IEEE80211_MAX_SSID_LEN];
6058 			u8 id_len, id_up_len;
6059 		} mesh;
6060 		struct {
6061 			struct cfg80211_chan_def preset_chandef;
6062 			u8 ssid[IEEE80211_MAX_SSID_LEN];
6063 			u8 ssid_len;
6064 		} ap;
6065 		struct {
6066 			struct cfg80211_internal_bss *current_bss;
6067 			struct cfg80211_chan_def chandef;
6068 			int beacon_interval;
6069 			u8 ssid[IEEE80211_MAX_SSID_LEN];
6070 			u8 ssid_len;
6071 		} ibss;
6072 		struct {
6073 			struct cfg80211_chan_def chandef;
6074 		} ocb;
6075 	} u;
6076 
6077 	struct {
6078 		u8 addr[ETH_ALEN] __aligned(2);
6079 		union {
6080 			struct {
6081 				unsigned int beacon_interval;
6082 				struct cfg80211_chan_def chandef;
6083 			} ap;
6084 			struct {
6085 				struct cfg80211_internal_bss *current_bss;
6086 			} client;
6087 		};
6088 	} links[IEEE80211_MLD_MAX_NUM_LINKS];
6089 	u16 valid_links;
6090 };
6091 
wdev_address(struct wireless_dev * wdev)6092 static inline const u8 *wdev_address(struct wireless_dev *wdev)
6093 {
6094 	if (wdev->netdev)
6095 		return wdev->netdev->dev_addr;
6096 	return wdev->address;
6097 }
6098 
wdev_running(struct wireless_dev * wdev)6099 static inline bool wdev_running(struct wireless_dev *wdev)
6100 {
6101 	if (wdev->netdev)
6102 		return netif_running(wdev->netdev);
6103 	return wdev->is_running;
6104 }
6105 
6106 /**
6107  * wdev_priv - return wiphy priv from wireless_dev
6108  *
6109  * @wdev: The wireless device whose wiphy's priv pointer to return
6110  * Return: The wiphy priv of @wdev.
6111  */
wdev_priv(struct wireless_dev * wdev)6112 static inline void *wdev_priv(struct wireless_dev *wdev)
6113 {
6114 	BUG_ON(!wdev);
6115 	return wiphy_priv(wdev->wiphy);
6116 }
6117 
6118 /**
6119  * wdev_chandef - return chandef pointer from wireless_dev
6120  * @wdev: the wdev
6121  * @link_id: the link ID for MLO
6122  *
6123  * Return: The chandef depending on the mode, or %NULL.
6124  */
6125 struct cfg80211_chan_def *wdev_chandef(struct wireless_dev *wdev,
6126 				       unsigned int link_id);
6127 
WARN_INVALID_LINK_ID(struct wireless_dev * wdev,unsigned int link_id)6128 static inline void WARN_INVALID_LINK_ID(struct wireless_dev *wdev,
6129 					unsigned int link_id)
6130 {
6131 	WARN_ON(link_id && !wdev->valid_links);
6132 	WARN_ON(wdev->valid_links &&
6133 		!(wdev->valid_links & BIT(link_id)));
6134 }
6135 
6136 #define for_each_valid_link(link_info, link_id)			\
6137 	for (link_id = 0;					\
6138 	     link_id < ((link_info)->valid_links ?		\
6139 			ARRAY_SIZE((link_info)->links) : 1);	\
6140 	     link_id++)						\
6141 		if (!(link_info)->valid_links ||		\
6142 		    ((link_info)->valid_links & BIT(link_id)))
6143 
6144 /**
6145  * DOC: Utility functions
6146  *
6147  * cfg80211 offers a number of utility functions that can be useful.
6148  */
6149 
6150 /**
6151  * ieee80211_channel_equal - compare two struct ieee80211_channel
6152  *
6153  * @a: 1st struct ieee80211_channel
6154  * @b: 2nd struct ieee80211_channel
6155  * Return: true if center frequency of @a == @b
6156  */
6157 static inline bool
ieee80211_channel_equal(struct ieee80211_channel * a,struct ieee80211_channel * b)6158 ieee80211_channel_equal(struct ieee80211_channel *a,
6159 			struct ieee80211_channel *b)
6160 {
6161 	return (a->center_freq == b->center_freq &&
6162 		a->freq_offset == b->freq_offset);
6163 }
6164 
6165 /**
6166  * ieee80211_channel_to_khz - convert ieee80211_channel to frequency in KHz
6167  * @chan: struct ieee80211_channel to convert
6168  * Return: The corresponding frequency (in KHz)
6169  */
6170 static inline u32
ieee80211_channel_to_khz(const struct ieee80211_channel * chan)6171 ieee80211_channel_to_khz(const struct ieee80211_channel *chan)
6172 {
6173 	return MHZ_TO_KHZ(chan->center_freq) + chan->freq_offset;
6174 }
6175 
6176 /**
6177  * ieee80211_s1g_channel_width - get allowed channel width from @chan
6178  *
6179  * Only allowed for band NL80211_BAND_S1GHZ
6180  * @chan: channel
6181  * Return: The allowed channel width for this center_freq
6182  */
6183 enum nl80211_chan_width
6184 ieee80211_s1g_channel_width(const struct ieee80211_channel *chan);
6185 
6186 /**
6187  * ieee80211_channel_to_freq_khz - convert channel number to frequency
6188  * @chan: channel number
6189  * @band: band, necessary due to channel number overlap
6190  * Return: The corresponding frequency (in KHz), or 0 if the conversion failed.
6191  */
6192 u32 ieee80211_channel_to_freq_khz(int chan, enum nl80211_band band);
6193 
6194 /**
6195  * ieee80211_channel_to_frequency - convert channel number to frequency
6196  * @chan: channel number
6197  * @band: band, necessary due to channel number overlap
6198  * Return: The corresponding frequency (in MHz), or 0 if the conversion failed.
6199  */
6200 static inline int
ieee80211_channel_to_frequency(int chan,enum nl80211_band band)6201 ieee80211_channel_to_frequency(int chan, enum nl80211_band band)
6202 {
6203 	return KHZ_TO_MHZ(ieee80211_channel_to_freq_khz(chan, band));
6204 }
6205 
6206 /**
6207  * ieee80211_freq_khz_to_channel - convert frequency to channel number
6208  * @freq: center frequency in KHz
6209  * Return: The corresponding channel, or 0 if the conversion failed.
6210  */
6211 int ieee80211_freq_khz_to_channel(u32 freq);
6212 
6213 /**
6214  * ieee80211_frequency_to_channel - convert frequency to channel number
6215  * @freq: center frequency in MHz
6216  * Return: The corresponding channel, or 0 if the conversion failed.
6217  */
6218 static inline int
ieee80211_frequency_to_channel(int freq)6219 ieee80211_frequency_to_channel(int freq)
6220 {
6221 	return ieee80211_freq_khz_to_channel(MHZ_TO_KHZ(freq));
6222 }
6223 
6224 /**
6225  * ieee80211_get_channel_khz - get channel struct from wiphy for specified
6226  * frequency
6227  * @wiphy: the struct wiphy to get the channel for
6228  * @freq: the center frequency (in KHz) of the channel
6229  * Return: The channel struct from @wiphy at @freq.
6230  */
6231 struct ieee80211_channel *
6232 ieee80211_get_channel_khz(struct wiphy *wiphy, u32 freq);
6233 
6234 /**
6235  * ieee80211_get_channel - get channel struct from wiphy for specified frequency
6236  *
6237  * @wiphy: the struct wiphy to get the channel for
6238  * @freq: the center frequency (in MHz) of the channel
6239  * Return: The channel struct from @wiphy at @freq.
6240  */
6241 static inline struct ieee80211_channel *
ieee80211_get_channel(struct wiphy * wiphy,int freq)6242 ieee80211_get_channel(struct wiphy *wiphy, int freq)
6243 {
6244 	return ieee80211_get_channel_khz(wiphy, MHZ_TO_KHZ(freq));
6245 }
6246 
6247 /**
6248  * cfg80211_channel_is_psc - Check if the channel is a 6 GHz PSC
6249  * @chan: control channel to check
6250  *
6251  * The Preferred Scanning Channels (PSC) are defined in
6252  * Draft IEEE P802.11ax/D5.0, 26.17.2.3.3
6253  */
cfg80211_channel_is_psc(struct ieee80211_channel * chan)6254 static inline bool cfg80211_channel_is_psc(struct ieee80211_channel *chan)
6255 {
6256 	if (chan->band != NL80211_BAND_6GHZ)
6257 		return false;
6258 
6259 	return ieee80211_frequency_to_channel(chan->center_freq) % 16 == 5;
6260 }
6261 
6262 /**
6263  * ieee80211_get_response_rate - get basic rate for a given rate
6264  *
6265  * @sband: the band to look for rates in
6266  * @basic_rates: bitmap of basic rates
6267  * @bitrate: the bitrate for which to find the basic rate
6268  *
6269  * Return: The basic rate corresponding to a given bitrate, that
6270  * is the next lower bitrate contained in the basic rate map,
6271  * which is, for this function, given as a bitmap of indices of
6272  * rates in the band's bitrate table.
6273  */
6274 const struct ieee80211_rate *
6275 ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
6276 			    u32 basic_rates, int bitrate);
6277 
6278 /**
6279  * ieee80211_mandatory_rates - get mandatory rates for a given band
6280  * @sband: the band to look for rates in
6281  * @scan_width: width of the control channel
6282  *
6283  * This function returns a bitmap of the mandatory rates for the given
6284  * band, bits are set according to the rate position in the bitrates array.
6285  */
6286 u32 ieee80211_mandatory_rates(struct ieee80211_supported_band *sband,
6287 			      enum nl80211_bss_scan_width scan_width);
6288 
6289 /*
6290  * Radiotap parsing functions -- for controlled injection support
6291  *
6292  * Implemented in net/wireless/radiotap.c
6293  * Documentation in Documentation/networking/radiotap-headers.rst
6294  */
6295 
6296 struct radiotap_align_size {
6297 	uint8_t align:4, size:4;
6298 };
6299 
6300 struct ieee80211_radiotap_namespace {
6301 	const struct radiotap_align_size *align_size;
6302 	int n_bits;
6303 	uint32_t oui;
6304 	uint8_t subns;
6305 };
6306 
6307 struct ieee80211_radiotap_vendor_namespaces {
6308 	const struct ieee80211_radiotap_namespace *ns;
6309 	int n_ns;
6310 };
6311 
6312 /**
6313  * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args
6314  * @this_arg_index: index of current arg, valid after each successful call
6315  *	to ieee80211_radiotap_iterator_next()
6316  * @this_arg: pointer to current radiotap arg; it is valid after each
6317  *	call to ieee80211_radiotap_iterator_next() but also after
6318  *	ieee80211_radiotap_iterator_init() where it will point to
6319  *	the beginning of the actual data portion
6320  * @this_arg_size: length of the current arg, for convenience
6321  * @current_namespace: pointer to the current namespace definition
6322  *	(or internally %NULL if the current namespace is unknown)
6323  * @is_radiotap_ns: indicates whether the current namespace is the default
6324  *	radiotap namespace or not
6325  *
6326  * @_rtheader: pointer to the radiotap header we are walking through
6327  * @_max_length: length of radiotap header in cpu byte ordering
6328  * @_arg_index: next argument index
6329  * @_arg: next argument pointer
6330  * @_next_bitmap: internal pointer to next present u32
6331  * @_bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
6332  * @_vns: vendor namespace definitions
6333  * @_next_ns_data: beginning of the next namespace's data
6334  * @_reset_on_ext: internal; reset the arg index to 0 when going to the
6335  *	next bitmap word
6336  *
6337  * Describes the radiotap parser state. Fields prefixed with an underscore
6338  * must not be used by users of the parser, only by the parser internally.
6339  */
6340 
6341 struct ieee80211_radiotap_iterator {
6342 	struct ieee80211_radiotap_header *_rtheader;
6343 	const struct ieee80211_radiotap_vendor_namespaces *_vns;
6344 	const struct ieee80211_radiotap_namespace *current_namespace;
6345 
6346 	unsigned char *_arg, *_next_ns_data;
6347 	__le32 *_next_bitmap;
6348 
6349 	unsigned char *this_arg;
6350 	int this_arg_index;
6351 	int this_arg_size;
6352 
6353 	int is_radiotap_ns;
6354 
6355 	int _max_length;
6356 	int _arg_index;
6357 	uint32_t _bitmap_shifter;
6358 	int _reset_on_ext;
6359 };
6360 
6361 int
6362 ieee80211_radiotap_iterator_init(struct ieee80211_radiotap_iterator *iterator,
6363 				 struct ieee80211_radiotap_header *radiotap_header,
6364 				 int max_length,
6365 				 const struct ieee80211_radiotap_vendor_namespaces *vns);
6366 
6367 int
6368 ieee80211_radiotap_iterator_next(struct ieee80211_radiotap_iterator *iterator);
6369 
6370 
6371 extern const unsigned char rfc1042_header[6];
6372 extern const unsigned char bridge_tunnel_header[6];
6373 
6374 /**
6375  * ieee80211_get_hdrlen_from_skb - get header length from data
6376  *
6377  * @skb: the frame
6378  *
6379  * Given an skb with a raw 802.11 header at the data pointer this function
6380  * returns the 802.11 header length.
6381  *
6382  * Return: The 802.11 header length in bytes (not including encryption
6383  * headers). Or 0 if the data in the sk_buff is too short to contain a valid
6384  * 802.11 header.
6385  */
6386 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb);
6387 
6388 /**
6389  * ieee80211_hdrlen - get header length in bytes from frame control
6390  * @fc: frame control field in little-endian format
6391  * Return: The header length in bytes.
6392  */
6393 unsigned int __attribute_const__ ieee80211_hdrlen(__le16 fc);
6394 
6395 /**
6396  * ieee80211_get_mesh_hdrlen - get mesh extension header length
6397  * @meshhdr: the mesh extension header, only the flags field
6398  *	(first byte) will be accessed
6399  * Return: The length of the extension header, which is always at
6400  * least 6 bytes and at most 18 if address 5 and 6 are present.
6401  */
6402 unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr);
6403 
6404 /**
6405  * DOC: Data path helpers
6406  *
6407  * In addition to generic utilities, cfg80211 also offers
6408  * functions that help implement the data path for devices
6409  * that do not do the 802.11/802.3 conversion on the device.
6410  */
6411 
6412 /**
6413  * ieee80211_data_to_8023_exthdr - convert an 802.11 data frame to 802.3
6414  * @skb: the 802.11 data frame
6415  * @ehdr: pointer to a &struct ethhdr that will get the header, instead
6416  *	of it being pushed into the SKB
6417  * @addr: the device MAC address
6418  * @iftype: the virtual interface type
6419  * @data_offset: offset of payload after the 802.11 header
6420  * @is_amsdu: true if the 802.11 header is A-MSDU
6421  * Return: 0 on success. Non-zero on error.
6422  */
6423 int ieee80211_data_to_8023_exthdr(struct sk_buff *skb, struct ethhdr *ehdr,
6424 				  const u8 *addr, enum nl80211_iftype iftype,
6425 				  u8 data_offset, bool is_amsdu);
6426 
6427 /**
6428  * ieee80211_data_to_8023 - convert an 802.11 data frame to 802.3
6429  * @skb: the 802.11 data frame
6430  * @addr: the device MAC address
6431  * @iftype: the virtual interface type
6432  * Return: 0 on success. Non-zero on error.
6433  */
ieee80211_data_to_8023(struct sk_buff * skb,const u8 * addr,enum nl80211_iftype iftype)6434 static inline int ieee80211_data_to_8023(struct sk_buff *skb, const u8 *addr,
6435 					 enum nl80211_iftype iftype)
6436 {
6437 	return ieee80211_data_to_8023_exthdr(skb, NULL, addr, iftype, 0, false);
6438 }
6439 
6440 /**
6441  * ieee80211_is_valid_amsdu - check if subframe lengths of an A-MSDU are valid
6442  *
6443  * This is used to detect non-standard A-MSDU frames, e.g. the ones generated
6444  * by ath10k and ath11k, where the subframe length includes the length of the
6445  * mesh control field.
6446  *
6447  * @skb: The input A-MSDU frame without any headers.
6448  * @mesh_hdr: the type of mesh header to test
6449  *	0: non-mesh A-MSDU length field
6450  *	1: big-endian mesh A-MSDU length field
6451  *	2: little-endian mesh A-MSDU length field
6452  * Returns: true if subframe header lengths are valid for the @mesh_hdr mode
6453  */
6454 bool ieee80211_is_valid_amsdu(struct sk_buff *skb, u8 mesh_hdr);
6455 
6456 /**
6457  * ieee80211_amsdu_to_8023s - decode an IEEE 802.11n A-MSDU frame
6458  *
6459  * Decode an IEEE 802.11 A-MSDU and convert it to a list of 802.3 frames.
6460  * The @list will be empty if the decode fails. The @skb must be fully
6461  * header-less before being passed in here; it is freed in this function.
6462  *
6463  * @skb: The input A-MSDU frame without any headers.
6464  * @list: The output list of 802.3 frames. It must be allocated and
6465  *	initialized by the caller.
6466  * @addr: The device MAC address.
6467  * @iftype: The device interface type.
6468  * @extra_headroom: The hardware extra headroom for SKBs in the @list.
6469  * @check_da: DA to check in the inner ethernet header, or NULL
6470  * @check_sa: SA to check in the inner ethernet header, or NULL
6471  * @mesh_control: see mesh_hdr in ieee80211_is_valid_amsdu
6472  */
6473 void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list,
6474 			      const u8 *addr, enum nl80211_iftype iftype,
6475 			      const unsigned int extra_headroom,
6476 			      const u8 *check_da, const u8 *check_sa,
6477 			      u8 mesh_control);
6478 
6479 /**
6480  * ieee80211_get_8023_tunnel_proto - get RFC1042 or bridge tunnel encap protocol
6481  *
6482  * Check for RFC1042 or bridge tunnel header and fetch the encapsulated
6483  * protocol.
6484  *
6485  * @hdr: pointer to the MSDU payload
6486  * @proto: destination pointer to store the protocol
6487  * Return: true if encapsulation was found
6488  */
6489 bool ieee80211_get_8023_tunnel_proto(const void *hdr, __be16 *proto);
6490 
6491 /**
6492  * ieee80211_strip_8023_mesh_hdr - strip mesh header from converted 802.3 frames
6493  *
6494  * Strip the mesh header, which was left in by ieee80211_data_to_8023 as part
6495  * of the MSDU data. Also move any source/destination addresses from the mesh
6496  * header to the ethernet header (if present).
6497  *
6498  * @skb: The 802.3 frame with embedded mesh header
6499  */
6500 int ieee80211_strip_8023_mesh_hdr(struct sk_buff *skb);
6501 
6502 /**
6503  * cfg80211_classify8021d - determine the 802.1p/1d tag for a data frame
6504  * @skb: the data frame
6505  * @qos_map: Interworking QoS mapping or %NULL if not in use
6506  * Return: The 802.1p/1d tag.
6507  */
6508 unsigned int cfg80211_classify8021d(struct sk_buff *skb,
6509 				    struct cfg80211_qos_map *qos_map);
6510 
6511 /**
6512  * cfg80211_find_elem_match - match information element and byte array in data
6513  *
6514  * @eid: element ID
6515  * @ies: data consisting of IEs
6516  * @len: length of data
6517  * @match: byte array to match
6518  * @match_len: number of bytes in the match array
6519  * @match_offset: offset in the IE data where the byte array should match.
6520  *	Note the difference to cfg80211_find_ie_match() which considers
6521  *	the offset to start from the element ID byte, but here we take
6522  *	the data portion instead.
6523  *
6524  * Return: %NULL if the element ID could not be found or if
6525  * the element is invalid (claims to be longer than the given
6526  * data) or if the byte array doesn't match; otherwise return the
6527  * requested element struct.
6528  *
6529  * Note: There are no checks on the element length other than
6530  * having to fit into the given data and being large enough for the
6531  * byte array to match.
6532  */
6533 const struct element *
6534 cfg80211_find_elem_match(u8 eid, const u8 *ies, unsigned int len,
6535 			 const u8 *match, unsigned int match_len,
6536 			 unsigned int match_offset);
6537 
6538 /**
6539  * cfg80211_find_ie_match - match information element and byte array in data
6540  *
6541  * @eid: element ID
6542  * @ies: data consisting of IEs
6543  * @len: length of data
6544  * @match: byte array to match
6545  * @match_len: number of bytes in the match array
6546  * @match_offset: offset in the IE where the byte array should match.
6547  *	If match_len is zero, this must also be set to zero.
6548  *	Otherwise this must be set to 2 or more, because the first
6549  *	byte is the element id, which is already compared to eid, and
6550  *	the second byte is the IE length.
6551  *
6552  * Return: %NULL if the element ID could not be found or if
6553  * the element is invalid (claims to be longer than the given
6554  * data) or if the byte array doesn't match, or a pointer to the first
6555  * byte of the requested element, that is the byte containing the
6556  * element ID.
6557  *
6558  * Note: There are no checks on the element length other than
6559  * having to fit into the given data and being large enough for the
6560  * byte array to match.
6561  */
6562 static inline const u8 *
cfg80211_find_ie_match(u8 eid,const u8 * ies,unsigned int len,const u8 * match,unsigned int match_len,unsigned int match_offset)6563 cfg80211_find_ie_match(u8 eid, const u8 *ies, unsigned int len,
6564 		       const u8 *match, unsigned int match_len,
6565 		       unsigned int match_offset)
6566 {
6567 	/* match_offset can't be smaller than 2, unless match_len is
6568 	 * zero, in which case match_offset must be zero as well.
6569 	 */
6570 	if (WARN_ON((match_len && match_offset < 2) ||
6571 		    (!match_len && match_offset)))
6572 		return NULL;
6573 
6574 	return (const void *)cfg80211_find_elem_match(eid, ies, len,
6575 						      match, match_len,
6576 						      match_offset ?
6577 							match_offset - 2 : 0);
6578 }
6579 
6580 /**
6581  * cfg80211_find_elem - find information element in data
6582  *
6583  * @eid: element ID
6584  * @ies: data consisting of IEs
6585  * @len: length of data
6586  *
6587  * Return: %NULL if the element ID could not be found or if
6588  * the element is invalid (claims to be longer than the given
6589  * data) or if the byte array doesn't match; otherwise return the
6590  * requested element struct.
6591  *
6592  * Note: There are no checks on the element length other than
6593  * having to fit into the given data.
6594  */
6595 static inline const struct element *
cfg80211_find_elem(u8 eid,const u8 * ies,int len)6596 cfg80211_find_elem(u8 eid, const u8 *ies, int len)
6597 {
6598 	return cfg80211_find_elem_match(eid, ies, len, NULL, 0, 0);
6599 }
6600 
6601 /**
6602  * cfg80211_find_ie - find information element in data
6603  *
6604  * @eid: element ID
6605  * @ies: data consisting of IEs
6606  * @len: length of data
6607  *
6608  * Return: %NULL if the element ID could not be found or if
6609  * the element is invalid (claims to be longer than the given
6610  * data), or a pointer to the first byte of the requested
6611  * element, that is the byte containing the element ID.
6612  *
6613  * Note: There are no checks on the element length other than
6614  * having to fit into the given data.
6615  */
cfg80211_find_ie(u8 eid,const u8 * ies,int len)6616 static inline const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len)
6617 {
6618 	return cfg80211_find_ie_match(eid, ies, len, NULL, 0, 0);
6619 }
6620 
6621 /**
6622  * cfg80211_find_ext_elem - find information element with EID Extension in data
6623  *
6624  * @ext_eid: element ID Extension
6625  * @ies: data consisting of IEs
6626  * @len: length of data
6627  *
6628  * Return: %NULL if the etended element could not be found or if
6629  * the element is invalid (claims to be longer than the given
6630  * data) or if the byte array doesn't match; otherwise return the
6631  * requested element struct.
6632  *
6633  * Note: There are no checks on the element length other than
6634  * having to fit into the given data.
6635  */
6636 static inline const struct element *
cfg80211_find_ext_elem(u8 ext_eid,const u8 * ies,int len)6637 cfg80211_find_ext_elem(u8 ext_eid, const u8 *ies, int len)
6638 {
6639 	return cfg80211_find_elem_match(WLAN_EID_EXTENSION, ies, len,
6640 					&ext_eid, 1, 0);
6641 }
6642 
6643 /**
6644  * cfg80211_find_ext_ie - find information element with EID Extension in data
6645  *
6646  * @ext_eid: element ID Extension
6647  * @ies: data consisting of IEs
6648  * @len: length of data
6649  *
6650  * Return: %NULL if the extended element ID could not be found or if
6651  * the element is invalid (claims to be longer than the given
6652  * data), or a pointer to the first byte of the requested
6653  * element, that is the byte containing the element ID.
6654  *
6655  * Note: There are no checks on the element length other than
6656  * having to fit into the given data.
6657  */
cfg80211_find_ext_ie(u8 ext_eid,const u8 * ies,int len)6658 static inline const u8 *cfg80211_find_ext_ie(u8 ext_eid, const u8 *ies, int len)
6659 {
6660 	return cfg80211_find_ie_match(WLAN_EID_EXTENSION, ies, len,
6661 				      &ext_eid, 1, 2);
6662 }
6663 
6664 /**
6665  * cfg80211_find_vendor_elem - find vendor specific information element in data
6666  *
6667  * @oui: vendor OUI
6668  * @oui_type: vendor-specific OUI type (must be < 0xff), negative means any
6669  * @ies: data consisting of IEs
6670  * @len: length of data
6671  *
6672  * Return: %NULL if the vendor specific element ID could not be found or if the
6673  * element is invalid (claims to be longer than the given data); otherwise
6674  * return the element structure for the requested element.
6675  *
6676  * Note: There are no checks on the element length other than having to fit into
6677  * the given data.
6678  */
6679 const struct element *cfg80211_find_vendor_elem(unsigned int oui, int oui_type,
6680 						const u8 *ies,
6681 						unsigned int len);
6682 
6683 /**
6684  * cfg80211_find_vendor_ie - find vendor specific information element in data
6685  *
6686  * @oui: vendor OUI
6687  * @oui_type: vendor-specific OUI type (must be < 0xff), negative means any
6688  * @ies: data consisting of IEs
6689  * @len: length of data
6690  *
6691  * Return: %NULL if the vendor specific element ID could not be found or if the
6692  * element is invalid (claims to be longer than the given data), or a pointer to
6693  * the first byte of the requested element, that is the byte containing the
6694  * element ID.
6695  *
6696  * Note: There are no checks on the element length other than having to fit into
6697  * the given data.
6698  */
6699 static inline const u8 *
cfg80211_find_vendor_ie(unsigned int oui,int oui_type,const u8 * ies,unsigned int len)6700 cfg80211_find_vendor_ie(unsigned int oui, int oui_type,
6701 			const u8 *ies, unsigned int len)
6702 {
6703 	return (const void *)cfg80211_find_vendor_elem(oui, oui_type, ies, len);
6704 }
6705 
6706 /**
6707  * cfg80211_defragment_element - Defrag the given element data into a buffer
6708  *
6709  * @elem: the element to defragment
6710  * @ies: elements where @elem is contained
6711  * @ieslen: length of @ies
6712  * @data: buffer to store element data
6713  * @data_len: length of @data
6714  * @frag_id: the element ID of fragments
6715  *
6716  * Return: length of @data, or -EINVAL on error
6717  *
6718  * Copy out all data from an element that may be fragmented into @data, while
6719  * skipping all headers.
6720  *
6721  * The function uses memmove() internally. It is acceptable to defragment an
6722  * element in-place.
6723  */
6724 ssize_t cfg80211_defragment_element(const struct element *elem, const u8 *ies,
6725 				    size_t ieslen, u8 *data, size_t data_len,
6726 				    u8 frag_id);
6727 
6728 /**
6729  * cfg80211_send_layer2_update - send layer 2 update frame
6730  *
6731  * @dev: network device
6732  * @addr: STA MAC address
6733  *
6734  * Wireless drivers can use this function to update forwarding tables in bridge
6735  * devices upon STA association.
6736  */
6737 void cfg80211_send_layer2_update(struct net_device *dev, const u8 *addr);
6738 
6739 /**
6740  * DOC: Regulatory enforcement infrastructure
6741  *
6742  * TODO
6743  */
6744 
6745 /**
6746  * regulatory_hint - driver hint to the wireless core a regulatory domain
6747  * @wiphy: the wireless device giving the hint (used only for reporting
6748  *	conflicts)
6749  * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain
6750  *	should be in. If @rd is set this should be NULL. Note that if you
6751  *	set this to NULL you should still set rd->alpha2 to some accepted
6752  *	alpha2.
6753  *
6754  * Wireless drivers can use this function to hint to the wireless core
6755  * what it believes should be the current regulatory domain by
6756  * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory
6757  * domain should be in or by providing a completely build regulatory domain.
6758  * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried
6759  * for a regulatory domain structure for the respective country.
6760  *
6761  * The wiphy must have been registered to cfg80211 prior to this call.
6762  * For cfg80211 drivers this means you must first use wiphy_register(),
6763  * for mac80211 drivers you must first use ieee80211_register_hw().
6764  *
6765  * Drivers should check the return value, its possible you can get
6766  * an -ENOMEM.
6767  *
6768  * Return: 0 on success. -ENOMEM.
6769  */
6770 int regulatory_hint(struct wiphy *wiphy, const char *alpha2);
6771 
6772 /**
6773  * regulatory_set_wiphy_regd - set regdom info for self managed drivers
6774  * @wiphy: the wireless device we want to process the regulatory domain on
6775  * @rd: the regulatory domain informatoin to use for this wiphy
6776  *
6777  * Set the regulatory domain information for self-managed wiphys, only they
6778  * may use this function. See %REGULATORY_WIPHY_SELF_MANAGED for more
6779  * information.
6780  *
6781  * Return: 0 on success. -EINVAL, -EPERM
6782  */
6783 int regulatory_set_wiphy_regd(struct wiphy *wiphy,
6784 			      struct ieee80211_regdomain *rd);
6785 
6786 /**
6787  * regulatory_set_wiphy_regd_sync - set regdom for self-managed drivers
6788  * @wiphy: the wireless device we want to process the regulatory domain on
6789  * @rd: the regulatory domain information to use for this wiphy
6790  *
6791  * This functions requires the RTNL and the wiphy mutex to be held and
6792  * applies the new regdomain synchronously to this wiphy. For more details
6793  * see regulatory_set_wiphy_regd().
6794  *
6795  * Return: 0 on success. -EINVAL, -EPERM
6796  */
6797 int regulatory_set_wiphy_regd_sync(struct wiphy *wiphy,
6798 				   struct ieee80211_regdomain *rd);
6799 
6800 /**
6801  * wiphy_apply_custom_regulatory - apply a custom driver regulatory domain
6802  * @wiphy: the wireless device we want to process the regulatory domain on
6803  * @regd: the custom regulatory domain to use for this wiphy
6804  *
6805  * Drivers can sometimes have custom regulatory domains which do not apply
6806  * to a specific country. Drivers can use this to apply such custom regulatory
6807  * domains. This routine must be called prior to wiphy registration. The
6808  * custom regulatory domain will be trusted completely and as such previous
6809  * default channel settings will be disregarded. If no rule is found for a
6810  * channel on the regulatory domain the channel will be disabled.
6811  * Drivers using this for a wiphy should also set the wiphy flag
6812  * REGULATORY_CUSTOM_REG or cfg80211 will set it for the wiphy
6813  * that called this helper.
6814  */
6815 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
6816 				   const struct ieee80211_regdomain *regd);
6817 
6818 /**
6819  * freq_reg_info - get regulatory information for the given frequency
6820  * @wiphy: the wiphy for which we want to process this rule for
6821  * @center_freq: Frequency in KHz for which we want regulatory information for
6822  *
6823  * Use this function to get the regulatory rule for a specific frequency on
6824  * a given wireless device. If the device has a specific regulatory domain
6825  * it wants to follow we respect that unless a country IE has been received
6826  * and processed already.
6827  *
6828  * Return: A valid pointer, or, when an error occurs, for example if no rule
6829  * can be found, the return value is encoded using ERR_PTR(). Use IS_ERR() to
6830  * check and PTR_ERR() to obtain the numeric return value. The numeric return
6831  * value will be -ERANGE if we determine the given center_freq does not even
6832  * have a regulatory rule for a frequency range in the center_freq's band.
6833  * See freq_in_rule_band() for our current definition of a band -- this is
6834  * purely subjective and right now it's 802.11 specific.
6835  */
6836 const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
6837 					       u32 center_freq);
6838 
6839 /**
6840  * reg_initiator_name - map regulatory request initiator enum to name
6841  * @initiator: the regulatory request initiator
6842  *
6843  * You can use this to map the regulatory request initiator enum to a
6844  * proper string representation.
6845  */
6846 const char *reg_initiator_name(enum nl80211_reg_initiator initiator);
6847 
6848 /**
6849  * regulatory_pre_cac_allowed - check if pre-CAC allowed in the current regdom
6850  * @wiphy: wiphy for which pre-CAC capability is checked.
6851  *
6852  * Pre-CAC is allowed only in some regdomains (notable ETSI).
6853  */
6854 bool regulatory_pre_cac_allowed(struct wiphy *wiphy);
6855 
6856 /**
6857  * DOC: Internal regulatory db functions
6858  *
6859  */
6860 
6861 /**
6862  * reg_query_regdb_wmm -  Query internal regulatory db for wmm rule
6863  * Regulatory self-managed driver can use it to proactively
6864  *
6865  * @alpha2: the ISO/IEC 3166 alpha2 wmm rule to be queried.
6866  * @freq: the freqency(in MHz) to be queried.
6867  * @rule: pointer to store the wmm rule from the regulatory db.
6868  *
6869  * Self-managed wireless drivers can use this function to  query
6870  * the internal regulatory database to check whether the given
6871  * ISO/IEC 3166 alpha2 country and freq have wmm rule limitations.
6872  *
6873  * Drivers should check the return value, its possible you can get
6874  * an -ENODATA.
6875  *
6876  * Return: 0 on success. -ENODATA.
6877  */
6878 int reg_query_regdb_wmm(char *alpha2, int freq,
6879 			struct ieee80211_reg_rule *rule);
6880 
6881 /*
6882  * callbacks for asynchronous cfg80211 methods, notification
6883  * functions and BSS handling helpers
6884  */
6885 
6886 /**
6887  * cfg80211_scan_done - notify that scan finished
6888  *
6889  * @request: the corresponding scan request
6890  * @info: information about the completed scan
6891  */
6892 void cfg80211_scan_done(struct cfg80211_scan_request *request,
6893 			struct cfg80211_scan_info *info);
6894 
6895 /**
6896  * cfg80211_sched_scan_results - notify that new scan results are available
6897  *
6898  * @wiphy: the wiphy which got scheduled scan results
6899  * @reqid: identifier for the related scheduled scan request
6900  */
6901 void cfg80211_sched_scan_results(struct wiphy *wiphy, u64 reqid);
6902 
6903 /**
6904  * cfg80211_sched_scan_stopped - notify that the scheduled scan has stopped
6905  *
6906  * @wiphy: the wiphy on which the scheduled scan stopped
6907  * @reqid: identifier for the related scheduled scan request
6908  *
6909  * The driver can call this function to inform cfg80211 that the
6910  * scheduled scan had to be stopped, for whatever reason.  The driver
6911  * is then called back via the sched_scan_stop operation when done.
6912  */
6913 void cfg80211_sched_scan_stopped(struct wiphy *wiphy, u64 reqid);
6914 
6915 /**
6916  * cfg80211_sched_scan_stopped_locked - notify that the scheduled scan has stopped
6917  *
6918  * @wiphy: the wiphy on which the scheduled scan stopped
6919  * @reqid: identifier for the related scheduled scan request
6920  *
6921  * The driver can call this function to inform cfg80211 that the
6922  * scheduled scan had to be stopped, for whatever reason.  The driver
6923  * is then called back via the sched_scan_stop operation when done.
6924  * This function should be called with the wiphy mutex held.
6925  */
6926 void cfg80211_sched_scan_stopped_locked(struct wiphy *wiphy, u64 reqid);
6927 
6928 /**
6929  * cfg80211_inform_bss_frame_data - inform cfg80211 of a received BSS frame
6930  * @wiphy: the wiphy reporting the BSS
6931  * @data: the BSS metadata
6932  * @mgmt: the management frame (probe response or beacon)
6933  * @len: length of the management frame
6934  * @gfp: context flags
6935  *
6936  * This informs cfg80211 that BSS information was found and
6937  * the BSS should be updated/added.
6938  *
6939  * Return: A referenced struct, must be released with cfg80211_put_bss()!
6940  * Or %NULL on error.
6941  */
6942 struct cfg80211_bss * __must_check
6943 cfg80211_inform_bss_frame_data(struct wiphy *wiphy,
6944 			       struct cfg80211_inform_bss *data,
6945 			       struct ieee80211_mgmt *mgmt, size_t len,
6946 			       gfp_t gfp);
6947 
6948 static inline struct cfg80211_bss * __must_check
cfg80211_inform_bss_width_frame(struct wiphy * wiphy,struct ieee80211_channel * rx_channel,enum nl80211_bss_scan_width scan_width,struct ieee80211_mgmt * mgmt,size_t len,s32 signal,gfp_t gfp)6949 cfg80211_inform_bss_width_frame(struct wiphy *wiphy,
6950 				struct ieee80211_channel *rx_channel,
6951 				enum nl80211_bss_scan_width scan_width,
6952 				struct ieee80211_mgmt *mgmt, size_t len,
6953 				s32 signal, gfp_t gfp)
6954 {
6955 	struct cfg80211_inform_bss data = {
6956 		.chan = rx_channel,
6957 		.scan_width = scan_width,
6958 		.signal = signal,
6959 	};
6960 
6961 	return cfg80211_inform_bss_frame_data(wiphy, &data, mgmt, len, gfp);
6962 }
6963 
6964 static inline struct cfg80211_bss * __must_check
cfg80211_inform_bss_frame(struct wiphy * wiphy,struct ieee80211_channel * rx_channel,struct ieee80211_mgmt * mgmt,size_t len,s32 signal,gfp_t gfp)6965 cfg80211_inform_bss_frame(struct wiphy *wiphy,
6966 			  struct ieee80211_channel *rx_channel,
6967 			  struct ieee80211_mgmt *mgmt, size_t len,
6968 			  s32 signal, gfp_t gfp)
6969 {
6970 	struct cfg80211_inform_bss data = {
6971 		.chan = rx_channel,
6972 		.scan_width = NL80211_BSS_CHAN_WIDTH_20,
6973 		.signal = signal,
6974 	};
6975 
6976 	return cfg80211_inform_bss_frame_data(wiphy, &data, mgmt, len, gfp);
6977 }
6978 
6979 /**
6980  * cfg80211_gen_new_bssid - generate a nontransmitted BSSID for multi-BSSID
6981  * @bssid: transmitter BSSID
6982  * @max_bssid: max BSSID indicator, taken from Multiple BSSID element
6983  * @mbssid_index: BSSID index, taken from Multiple BSSID index element
6984  * @new_bssid: calculated nontransmitted BSSID
6985  */
cfg80211_gen_new_bssid(const u8 * bssid,u8 max_bssid,u8 mbssid_index,u8 * new_bssid)6986 static inline void cfg80211_gen_new_bssid(const u8 *bssid, u8 max_bssid,
6987 					  u8 mbssid_index, u8 *new_bssid)
6988 {
6989 	u64 bssid_u64 = ether_addr_to_u64(bssid);
6990 	u64 mask = GENMASK_ULL(max_bssid - 1, 0);
6991 	u64 new_bssid_u64;
6992 
6993 	new_bssid_u64 = bssid_u64 & ~mask;
6994 
6995 	new_bssid_u64 |= ((bssid_u64 & mask) + mbssid_index) & mask;
6996 
6997 	u64_to_ether_addr(new_bssid_u64, new_bssid);
6998 }
6999 
7000 /**
7001  * cfg80211_is_element_inherited - returns if element ID should be inherited
7002  * @element: element to check
7003  * @non_inherit_element: non inheritance element
7004  */
7005 bool cfg80211_is_element_inherited(const struct element *element,
7006 				   const struct element *non_inherit_element);
7007 
7008 /**
7009  * cfg80211_merge_profile - merges a MBSSID profile if it is split between IEs
7010  * @ie: ies
7011  * @ielen: length of IEs
7012  * @mbssid_elem: current MBSSID element
7013  * @sub_elem: current MBSSID subelement (profile)
7014  * @merged_ie: location of the merged profile
7015  * @max_copy_len: max merged profile length
7016  */
7017 size_t cfg80211_merge_profile(const u8 *ie, size_t ielen,
7018 			      const struct element *mbssid_elem,
7019 			      const struct element *sub_elem,
7020 			      u8 *merged_ie, size_t max_copy_len);
7021 
7022 /**
7023  * enum cfg80211_bss_frame_type - frame type that the BSS data came from
7024  * @CFG80211_BSS_FTYPE_UNKNOWN: driver doesn't know whether the data is
7025  *	from a beacon or probe response
7026  * @CFG80211_BSS_FTYPE_BEACON: data comes from a beacon
7027  * @CFG80211_BSS_FTYPE_PRESP: data comes from a probe response
7028  */
7029 enum cfg80211_bss_frame_type {
7030 	CFG80211_BSS_FTYPE_UNKNOWN,
7031 	CFG80211_BSS_FTYPE_BEACON,
7032 	CFG80211_BSS_FTYPE_PRESP,
7033 };
7034 
7035 /**
7036  * cfg80211_get_ies_channel_number - returns the channel number from ies
7037  * @ie: IEs
7038  * @ielen: length of IEs
7039  * @band: enum nl80211_band of the channel
7040  *
7041  * Returns the channel number, or -1 if none could be determined.
7042  */
7043 int cfg80211_get_ies_channel_number(const u8 *ie, size_t ielen,
7044 				    enum nl80211_band band);
7045 
7046 /**
7047  * cfg80211_inform_bss_data - inform cfg80211 of a new BSS
7048  *
7049  * @wiphy: the wiphy reporting the BSS
7050  * @data: the BSS metadata
7051  * @ftype: frame type (if known)
7052  * @bssid: the BSSID of the BSS
7053  * @tsf: the TSF sent by the peer in the beacon/probe response (or 0)
7054  * @capability: the capability field sent by the peer
7055  * @beacon_interval: the beacon interval announced by the peer
7056  * @ie: additional IEs sent by the peer
7057  * @ielen: length of the additional IEs
7058  * @gfp: context flags
7059  *
7060  * This informs cfg80211 that BSS information was found and
7061  * the BSS should be updated/added.
7062  *
7063  * Return: A referenced struct, must be released with cfg80211_put_bss()!
7064  * Or %NULL on error.
7065  */
7066 struct cfg80211_bss * __must_check
7067 cfg80211_inform_bss_data(struct wiphy *wiphy,
7068 			 struct cfg80211_inform_bss *data,
7069 			 enum cfg80211_bss_frame_type ftype,
7070 			 const u8 *bssid, u64 tsf, u16 capability,
7071 			 u16 beacon_interval, const u8 *ie, size_t ielen,
7072 			 gfp_t gfp);
7073 
7074 static inline struct cfg80211_bss * __must_check
cfg80211_inform_bss_width(struct wiphy * wiphy,struct ieee80211_channel * rx_channel,enum nl80211_bss_scan_width scan_width,enum cfg80211_bss_frame_type ftype,const u8 * bssid,u64 tsf,u16 capability,u16 beacon_interval,const u8 * ie,size_t ielen,s32 signal,gfp_t gfp)7075 cfg80211_inform_bss_width(struct wiphy *wiphy,
7076 			  struct ieee80211_channel *rx_channel,
7077 			  enum nl80211_bss_scan_width scan_width,
7078 			  enum cfg80211_bss_frame_type ftype,
7079 			  const u8 *bssid, u64 tsf, u16 capability,
7080 			  u16 beacon_interval, const u8 *ie, size_t ielen,
7081 			  s32 signal, gfp_t gfp)
7082 {
7083 	struct cfg80211_inform_bss data = {
7084 		.chan = rx_channel,
7085 		.scan_width = scan_width,
7086 		.signal = signal,
7087 	};
7088 
7089 	return cfg80211_inform_bss_data(wiphy, &data, ftype, bssid, tsf,
7090 					capability, beacon_interval, ie, ielen,
7091 					gfp);
7092 }
7093 
7094 static inline struct cfg80211_bss * __must_check
cfg80211_inform_bss(struct wiphy * wiphy,struct ieee80211_channel * rx_channel,enum cfg80211_bss_frame_type ftype,const u8 * bssid,u64 tsf,u16 capability,u16 beacon_interval,const u8 * ie,size_t ielen,s32 signal,gfp_t gfp)7095 cfg80211_inform_bss(struct wiphy *wiphy,
7096 		    struct ieee80211_channel *rx_channel,
7097 		    enum cfg80211_bss_frame_type ftype,
7098 		    const u8 *bssid, u64 tsf, u16 capability,
7099 		    u16 beacon_interval, const u8 *ie, size_t ielen,
7100 		    s32 signal, gfp_t gfp)
7101 {
7102 	struct cfg80211_inform_bss data = {
7103 		.chan = rx_channel,
7104 		.scan_width = NL80211_BSS_CHAN_WIDTH_20,
7105 		.signal = signal,
7106 	};
7107 
7108 	return cfg80211_inform_bss_data(wiphy, &data, ftype, bssid, tsf,
7109 					capability, beacon_interval, ie, ielen,
7110 					gfp);
7111 }
7112 
7113 /**
7114  * cfg80211_get_bss - get a BSS reference
7115  * @wiphy: the wiphy this BSS struct belongs to
7116  * @channel: the channel to search on (or %NULL)
7117  * @bssid: the desired BSSID (or %NULL)
7118  * @ssid: the desired SSID (or %NULL)
7119  * @ssid_len: length of the SSID (or 0)
7120  * @bss_type: type of BSS, see &enum ieee80211_bss_type
7121  * @privacy: privacy filter, see &enum ieee80211_privacy
7122  */
7123 struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
7124 				      struct ieee80211_channel *channel,
7125 				      const u8 *bssid,
7126 				      const u8 *ssid, size_t ssid_len,
7127 				      enum ieee80211_bss_type bss_type,
7128 				      enum ieee80211_privacy privacy);
7129 static inline struct cfg80211_bss *
cfg80211_get_ibss(struct wiphy * wiphy,struct ieee80211_channel * channel,const u8 * ssid,size_t ssid_len)7130 cfg80211_get_ibss(struct wiphy *wiphy,
7131 		  struct ieee80211_channel *channel,
7132 		  const u8 *ssid, size_t ssid_len)
7133 {
7134 	return cfg80211_get_bss(wiphy, channel, NULL, ssid, ssid_len,
7135 				IEEE80211_BSS_TYPE_IBSS,
7136 				IEEE80211_PRIVACY_ANY);
7137 }
7138 
7139 /**
7140  * cfg80211_ref_bss - reference BSS struct
7141  * @wiphy: the wiphy this BSS struct belongs to
7142  * @bss: the BSS struct to reference
7143  *
7144  * Increments the refcount of the given BSS struct.
7145  */
7146 void cfg80211_ref_bss(struct wiphy *wiphy, struct cfg80211_bss *bss);
7147 
7148 /**
7149  * cfg80211_put_bss - unref BSS struct
7150  * @wiphy: the wiphy this BSS struct belongs to
7151  * @bss: the BSS struct
7152  *
7153  * Decrements the refcount of the given BSS struct.
7154  */
7155 void cfg80211_put_bss(struct wiphy *wiphy, struct cfg80211_bss *bss);
7156 
7157 /**
7158  * cfg80211_unlink_bss - unlink BSS from internal data structures
7159  * @wiphy: the wiphy
7160  * @bss: the bss to remove
7161  *
7162  * This function removes the given BSS from the internal data structures
7163  * thereby making it no longer show up in scan results etc. Use this
7164  * function when you detect a BSS is gone. Normally BSSes will also time
7165  * out, so it is not necessary to use this function at all.
7166  */
7167 void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *bss);
7168 
7169 /**
7170  * cfg80211_bss_iter - iterate all BSS entries
7171  *
7172  * This function iterates over the BSS entries associated with the given wiphy
7173  * and calls the callback for the iterated BSS. The iterator function is not
7174  * allowed to call functions that might modify the internal state of the BSS DB.
7175  *
7176  * @wiphy: the wiphy
7177  * @chandef: if given, the iterator function will be called only if the channel
7178  *     of the currently iterated BSS is a subset of the given channel.
7179  * @iter: the iterator function to call
7180  * @iter_data: an argument to the iterator function
7181  */
7182 void cfg80211_bss_iter(struct wiphy *wiphy,
7183 		       struct cfg80211_chan_def *chandef,
7184 		       void (*iter)(struct wiphy *wiphy,
7185 				    struct cfg80211_bss *bss,
7186 				    void *data),
7187 		       void *iter_data);
7188 
7189 static inline enum nl80211_bss_scan_width
cfg80211_chandef_to_scan_width(const struct cfg80211_chan_def * chandef)7190 cfg80211_chandef_to_scan_width(const struct cfg80211_chan_def *chandef)
7191 {
7192 	switch (chandef->width) {
7193 	case NL80211_CHAN_WIDTH_5:
7194 		return NL80211_BSS_CHAN_WIDTH_5;
7195 	case NL80211_CHAN_WIDTH_10:
7196 		return NL80211_BSS_CHAN_WIDTH_10;
7197 	default:
7198 		return NL80211_BSS_CHAN_WIDTH_20;
7199 	}
7200 }
7201 
7202 /**
7203  * cfg80211_rx_mlme_mgmt - notification of processed MLME management frame
7204  * @dev: network device
7205  * @buf: authentication frame (header + body)
7206  * @len: length of the frame data
7207  *
7208  * This function is called whenever an authentication, disassociation or
7209  * deauthentication frame has been received and processed in station mode.
7210  * After being asked to authenticate via cfg80211_ops::auth() the driver must
7211  * call either this function or cfg80211_auth_timeout().
7212  * After being asked to associate via cfg80211_ops::assoc() the driver must
7213  * call either this function or cfg80211_auth_timeout().
7214  * While connected, the driver must calls this for received and processed
7215  * disassociation and deauthentication frames. If the frame couldn't be used
7216  * because it was unprotected, the driver must call the function
7217  * cfg80211_rx_unprot_mlme_mgmt() instead.
7218  *
7219  * This function may sleep. The caller must hold the corresponding wdev's mutex.
7220  */
7221 void cfg80211_rx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len);
7222 
7223 /**
7224  * cfg80211_auth_timeout - notification of timed out authentication
7225  * @dev: network device
7226  * @addr: The MAC address of the device with which the authentication timed out
7227  *
7228  * This function may sleep. The caller must hold the corresponding wdev's
7229  * mutex.
7230  */
7231 void cfg80211_auth_timeout(struct net_device *dev, const u8 *addr);
7232 
7233 /**
7234  * struct cfg80211_rx_assoc_resp - association response data
7235  * @bss: the BSS that association was requested with, ownership of the pointer
7236  *	moves to cfg80211 in the call to cfg80211_rx_assoc_resp()
7237  * @buf: (Re)Association Response frame (header + body)
7238  * @len: length of the frame data
7239  * @uapsd_queues: bitmap of queues configured for uapsd. Same format
7240  *	as the AC bitmap in the QoS info field
7241  * @req_ies: information elements from the (Re)Association Request frame
7242  * @req_ies_len: length of req_ies data
7243  * @ap_mld_addr: AP MLD address (in case of MLO)
7244  * @links: per-link information indexed by link ID, use links[0] for
7245  *	non-MLO connections
7246  * @links.status: Set this (along with a BSS pointer) for links that
7247  *	were rejected by the AP.
7248  */
7249 struct cfg80211_rx_assoc_resp {
7250 	const u8 *buf;
7251 	size_t len;
7252 	const u8 *req_ies;
7253 	size_t req_ies_len;
7254 	int uapsd_queues;
7255 	const u8 *ap_mld_addr;
7256 	struct {
7257 		u8 addr[ETH_ALEN] __aligned(2);
7258 		struct cfg80211_bss *bss;
7259 		u16 status;
7260 	} links[IEEE80211_MLD_MAX_NUM_LINKS];
7261 };
7262 
7263 /**
7264  * cfg80211_rx_assoc_resp - notification of processed association response
7265  * @dev: network device
7266  * @data: association response data, &struct cfg80211_rx_assoc_resp
7267  *
7268  * After being asked to associate via cfg80211_ops::assoc() the driver must
7269  * call either this function or cfg80211_auth_timeout().
7270  *
7271  * This function may sleep. The caller must hold the corresponding wdev's mutex.
7272  */
7273 void cfg80211_rx_assoc_resp(struct net_device *dev,
7274 			    struct cfg80211_rx_assoc_resp *data);
7275 
7276 /**
7277  * struct cfg80211_assoc_failure - association failure data
7278  * @ap_mld_addr: AP MLD address, or %NULL
7279  * @bss: list of BSSes, must use entry 0 for non-MLO connections
7280  *	(@ap_mld_addr is %NULL)
7281  * @timeout: indicates the association failed due to timeout, otherwise
7282  *	the association was abandoned for a reason reported through some
7283  *	other API (e.g. deauth RX)
7284  */
7285 struct cfg80211_assoc_failure {
7286 	const u8 *ap_mld_addr;
7287 	struct cfg80211_bss *bss[IEEE80211_MLD_MAX_NUM_LINKS];
7288 	bool timeout;
7289 };
7290 
7291 /**
7292  * cfg80211_assoc_failure - notification of association failure
7293  * @dev: network device
7294  * @data: data describing the association failure
7295  *
7296  * This function may sleep. The caller must hold the corresponding wdev's mutex.
7297  */
7298 void cfg80211_assoc_failure(struct net_device *dev,
7299 			    struct cfg80211_assoc_failure *data);
7300 
7301 /**
7302  * cfg80211_tx_mlme_mgmt - notification of transmitted deauth/disassoc frame
7303  * @dev: network device
7304  * @buf: 802.11 frame (header + body)
7305  * @len: length of the frame data
7306  * @reconnect: immediate reconnect is desired (include the nl80211 attribute)
7307  *
7308  * This function is called whenever deauthentication has been processed in
7309  * station mode. This includes both received deauthentication frames and
7310  * locally generated ones. This function may sleep. The caller must hold the
7311  * corresponding wdev's mutex.
7312  */
7313 void cfg80211_tx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len,
7314 			   bool reconnect);
7315 
7316 /**
7317  * cfg80211_rx_unprot_mlme_mgmt - notification of unprotected mlme mgmt frame
7318  * @dev: network device
7319  * @buf: received management frame (header + body)
7320  * @len: length of the frame data
7321  *
7322  * This function is called whenever a received deauthentication or dissassoc
7323  * frame has been dropped in station mode because of MFP being used but the
7324  * frame was not protected. This is also used to notify reception of a Beacon
7325  * frame that was dropped because it did not include a valid MME MIC while
7326  * beacon protection was enabled (BIGTK configured in station mode).
7327  *
7328  * This function may sleep.
7329  */
7330 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev,
7331 				  const u8 *buf, size_t len);
7332 
7333 /**
7334  * cfg80211_michael_mic_failure - notification of Michael MIC failure (TKIP)
7335  * @dev: network device
7336  * @addr: The source MAC address of the frame
7337  * @key_type: The key type that the received frame used
7338  * @key_id: Key identifier (0..3). Can be -1 if missing.
7339  * @tsc: The TSC value of the frame that generated the MIC failure (6 octets)
7340  * @gfp: allocation flags
7341  *
7342  * This function is called whenever the local MAC detects a MIC failure in a
7343  * received frame. This matches with MLME-MICHAELMICFAILURE.indication()
7344  * primitive.
7345  */
7346 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
7347 				  enum nl80211_key_type key_type, int key_id,
7348 				  const u8 *tsc, gfp_t gfp);
7349 
7350 /**
7351  * cfg80211_ibss_joined - notify cfg80211 that device joined an IBSS
7352  *
7353  * @dev: network device
7354  * @bssid: the BSSID of the IBSS joined
7355  * @channel: the channel of the IBSS joined
7356  * @gfp: allocation flags
7357  *
7358  * This function notifies cfg80211 that the device joined an IBSS or
7359  * switched to a different BSSID. Before this function can be called,
7360  * either a beacon has to have been received from the IBSS, or one of
7361  * the cfg80211_inform_bss{,_frame} functions must have been called
7362  * with the locally generated beacon -- this guarantees that there is
7363  * always a scan result for this IBSS. cfg80211 will handle the rest.
7364  */
7365 void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
7366 			  struct ieee80211_channel *channel, gfp_t gfp);
7367 
7368 /**
7369  * cfg80211_notify_new_peer_candidate - notify cfg80211 of a new mesh peer
7370  * 					candidate
7371  *
7372  * @dev: network device
7373  * @macaddr: the MAC address of the new candidate
7374  * @ie: information elements advertised by the peer candidate
7375  * @ie_len: length of the information elements buffer
7376  * @sig_dbm: signal level in dBm
7377  * @gfp: allocation flags
7378  *
7379  * This function notifies cfg80211 that the mesh peer candidate has been
7380  * detected, most likely via a beacon or, less likely, via a probe response.
7381  * cfg80211 then sends a notification to userspace.
7382  */
7383 void cfg80211_notify_new_peer_candidate(struct net_device *dev,
7384 		const u8 *macaddr, const u8 *ie, u8 ie_len,
7385 		int sig_dbm, gfp_t gfp);
7386 
7387 /**
7388  * DOC: RFkill integration
7389  *
7390  * RFkill integration in cfg80211 is almost invisible to drivers,
7391  * as cfg80211 automatically registers an rfkill instance for each
7392  * wireless device it knows about. Soft kill is also translated
7393  * into disconnecting and turning all interfaces off, drivers are
7394  * expected to turn off the device when all interfaces are down.
7395  *
7396  * However, devices may have a hard RFkill line, in which case they
7397  * also need to interact with the rfkill subsystem, via cfg80211.
7398  * They can do this with a few helper functions documented here.
7399  */
7400 
7401 /**
7402  * wiphy_rfkill_set_hw_state_reason - notify cfg80211 about hw block state
7403  * @wiphy: the wiphy
7404  * @blocked: block status
7405  * @reason: one of reasons in &enum rfkill_hard_block_reasons
7406  */
7407 void wiphy_rfkill_set_hw_state_reason(struct wiphy *wiphy, bool blocked,
7408 				      enum rfkill_hard_block_reasons reason);
7409 
wiphy_rfkill_set_hw_state(struct wiphy * wiphy,bool blocked)7410 static inline void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
7411 {
7412 	wiphy_rfkill_set_hw_state_reason(wiphy, blocked,
7413 					 RFKILL_HARD_BLOCK_SIGNAL);
7414 }
7415 
7416 /**
7417  * wiphy_rfkill_start_polling - start polling rfkill
7418  * @wiphy: the wiphy
7419  */
7420 void wiphy_rfkill_start_polling(struct wiphy *wiphy);
7421 
7422 /**
7423  * wiphy_rfkill_stop_polling - stop polling rfkill
7424  * @wiphy: the wiphy
7425  */
wiphy_rfkill_stop_polling(struct wiphy * wiphy)7426 static inline void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
7427 {
7428 	rfkill_pause_polling(wiphy->rfkill);
7429 }
7430 
7431 /**
7432  * DOC: Vendor commands
7433  *
7434  * Occasionally, there are special protocol or firmware features that
7435  * can't be implemented very openly. For this and similar cases, the
7436  * vendor command functionality allows implementing the features with
7437  * (typically closed-source) userspace and firmware, using nl80211 as
7438  * the configuration mechanism.
7439  *
7440  * A driver supporting vendor commands must register them as an array
7441  * in struct wiphy, with handlers for each one, each command has an
7442  * OUI and sub command ID to identify it.
7443  *
7444  * Note that this feature should not be (ab)used to implement protocol
7445  * features that could openly be shared across drivers. In particular,
7446  * it must never be required to use vendor commands to implement any
7447  * "normal" functionality that higher-level userspace like connection
7448  * managers etc. need.
7449  */
7450 
7451 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
7452 					   enum nl80211_commands cmd,
7453 					   enum nl80211_attrs attr,
7454 					   int approxlen);
7455 
7456 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
7457 					   struct wireless_dev *wdev,
7458 					   enum nl80211_commands cmd,
7459 					   enum nl80211_attrs attr,
7460 					   unsigned int portid,
7461 					   int vendor_event_idx,
7462 					   int approxlen, gfp_t gfp);
7463 
7464 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp);
7465 
7466 /**
7467  * cfg80211_vendor_cmd_alloc_reply_skb - allocate vendor command reply
7468  * @wiphy: the wiphy
7469  * @approxlen: an upper bound of the length of the data that will
7470  *	be put into the skb
7471  *
7472  * This function allocates and pre-fills an skb for a reply to
7473  * a vendor command. Since it is intended for a reply, calling
7474  * it outside of a vendor command's doit() operation is invalid.
7475  *
7476  * The returned skb is pre-filled with some identifying data in
7477  * a way that any data that is put into the skb (with skb_put(),
7478  * nla_put() or similar) will end up being within the
7479  * %NL80211_ATTR_VENDOR_DATA attribute, so all that needs to be done
7480  * with the skb is adding data for the corresponding userspace tool
7481  * which can then read that data out of the vendor data attribute.
7482  * You must not modify the skb in any other way.
7483  *
7484  * When done, call cfg80211_vendor_cmd_reply() with the skb and return
7485  * its error code as the result of the doit() operation.
7486  *
7487  * Return: An allocated and pre-filled skb. %NULL if any errors happen.
7488  */
7489 static inline struct sk_buff *
cfg80211_vendor_cmd_alloc_reply_skb(struct wiphy * wiphy,int approxlen)7490 cfg80211_vendor_cmd_alloc_reply_skb(struct wiphy *wiphy, int approxlen)
7491 {
7492 	return __cfg80211_alloc_reply_skb(wiphy, NL80211_CMD_VENDOR,
7493 					  NL80211_ATTR_VENDOR_DATA, approxlen);
7494 }
7495 
7496 /**
7497  * cfg80211_vendor_cmd_reply - send the reply skb
7498  * @skb: The skb, must have been allocated with
7499  *	cfg80211_vendor_cmd_alloc_reply_skb()
7500  *
7501  * Since calling this function will usually be the last thing
7502  * before returning from the vendor command doit() you should
7503  * return the error code.  Note that this function consumes the
7504  * skb regardless of the return value.
7505  *
7506  * Return: An error code or 0 on success.
7507  */
7508 int cfg80211_vendor_cmd_reply(struct sk_buff *skb);
7509 
7510 /**
7511  * cfg80211_vendor_cmd_get_sender - get the current sender netlink ID
7512  * @wiphy: the wiphy
7513  *
7514  * Return the current netlink port ID in a vendor command handler.
7515  * Valid to call only there.
7516  */
7517 unsigned int cfg80211_vendor_cmd_get_sender(struct wiphy *wiphy);
7518 
7519 /**
7520  * cfg80211_vendor_event_alloc - allocate vendor-specific event skb
7521  * @wiphy: the wiphy
7522  * @wdev: the wireless device
7523  * @event_idx: index of the vendor event in the wiphy's vendor_events
7524  * @approxlen: an upper bound of the length of the data that will
7525  *	be put into the skb
7526  * @gfp: allocation flags
7527  *
7528  * This function allocates and pre-fills an skb for an event on the
7529  * vendor-specific multicast group.
7530  *
7531  * If wdev != NULL, both the ifindex and identifier of the specified
7532  * wireless device are added to the event message before the vendor data
7533  * attribute.
7534  *
7535  * When done filling the skb, call cfg80211_vendor_event() with the
7536  * skb to send the event.
7537  *
7538  * Return: An allocated and pre-filled skb. %NULL if any errors happen.
7539  */
7540 static inline struct sk_buff *
cfg80211_vendor_event_alloc(struct wiphy * wiphy,struct wireless_dev * wdev,int approxlen,int event_idx,gfp_t gfp)7541 cfg80211_vendor_event_alloc(struct wiphy *wiphy, struct wireless_dev *wdev,
7542 			     int approxlen, int event_idx, gfp_t gfp)
7543 {
7544 	return __cfg80211_alloc_event_skb(wiphy, wdev, NL80211_CMD_VENDOR,
7545 					  NL80211_ATTR_VENDOR_DATA,
7546 					  0, event_idx, approxlen, gfp);
7547 }
7548 
7549 /**
7550  * cfg80211_vendor_event_alloc_ucast - alloc unicast vendor-specific event skb
7551  * @wiphy: the wiphy
7552  * @wdev: the wireless device
7553  * @event_idx: index of the vendor event in the wiphy's vendor_events
7554  * @portid: port ID of the receiver
7555  * @approxlen: an upper bound of the length of the data that will
7556  *	be put into the skb
7557  * @gfp: allocation flags
7558  *
7559  * This function allocates and pre-fills an skb for an event to send to
7560  * a specific (userland) socket. This socket would previously have been
7561  * obtained by cfg80211_vendor_cmd_get_sender(), and the caller MUST take
7562  * care to register a netlink notifier to see when the socket closes.
7563  *
7564  * If wdev != NULL, both the ifindex and identifier of the specified
7565  * wireless device are added to the event message before the vendor data
7566  * attribute.
7567  *
7568  * When done filling the skb, call cfg80211_vendor_event() with the
7569  * skb to send the event.
7570  *
7571  * Return: An allocated and pre-filled skb. %NULL if any errors happen.
7572  */
7573 static inline struct sk_buff *
cfg80211_vendor_event_alloc_ucast(struct wiphy * wiphy,struct wireless_dev * wdev,unsigned int portid,int approxlen,int event_idx,gfp_t gfp)7574 cfg80211_vendor_event_alloc_ucast(struct wiphy *wiphy,
7575 				  struct wireless_dev *wdev,
7576 				  unsigned int portid, int approxlen,
7577 				  int event_idx, gfp_t gfp)
7578 {
7579 	return __cfg80211_alloc_event_skb(wiphy, wdev, NL80211_CMD_VENDOR,
7580 					  NL80211_ATTR_VENDOR_DATA,
7581 					  portid, event_idx, approxlen, gfp);
7582 }
7583 
7584 /**
7585  * cfg80211_vendor_event - send the event
7586  * @skb: The skb, must have been allocated with cfg80211_vendor_event_alloc()
7587  * @gfp: allocation flags
7588  *
7589  * This function sends the given @skb, which must have been allocated
7590  * by cfg80211_vendor_event_alloc(), as an event. It always consumes it.
7591  */
cfg80211_vendor_event(struct sk_buff * skb,gfp_t gfp)7592 static inline void cfg80211_vendor_event(struct sk_buff *skb, gfp_t gfp)
7593 {
7594 	__cfg80211_send_event_skb(skb, gfp);
7595 }
7596 
7597 #ifdef CONFIG_NL80211_TESTMODE
7598 /**
7599  * DOC: Test mode
7600  *
7601  * Test mode is a set of utility functions to allow drivers to
7602  * interact with driver-specific tools to aid, for instance,
7603  * factory programming.
7604  *
7605  * This chapter describes how drivers interact with it, for more
7606  * information see the nl80211 book's chapter on it.
7607  */
7608 
7609 /**
7610  * cfg80211_testmode_alloc_reply_skb - allocate testmode reply
7611  * @wiphy: the wiphy
7612  * @approxlen: an upper bound of the length of the data that will
7613  *	be put into the skb
7614  *
7615  * This function allocates and pre-fills an skb for a reply to
7616  * the testmode command. Since it is intended for a reply, calling
7617  * it outside of the @testmode_cmd operation is invalid.
7618  *
7619  * The returned skb is pre-filled with the wiphy index and set up in
7620  * a way that any data that is put into the skb (with skb_put(),
7621  * nla_put() or similar) will end up being within the
7622  * %NL80211_ATTR_TESTDATA attribute, so all that needs to be done
7623  * with the skb is adding data for the corresponding userspace tool
7624  * which can then read that data out of the testdata attribute. You
7625  * must not modify the skb in any other way.
7626  *
7627  * When done, call cfg80211_testmode_reply() with the skb and return
7628  * its error code as the result of the @testmode_cmd operation.
7629  *
7630  * Return: An allocated and pre-filled skb. %NULL if any errors happen.
7631  */
7632 static inline struct sk_buff *
cfg80211_testmode_alloc_reply_skb(struct wiphy * wiphy,int approxlen)7633 cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy, int approxlen)
7634 {
7635 	return __cfg80211_alloc_reply_skb(wiphy, NL80211_CMD_TESTMODE,
7636 					  NL80211_ATTR_TESTDATA, approxlen);
7637 }
7638 
7639 /**
7640  * cfg80211_testmode_reply - send the reply skb
7641  * @skb: The skb, must have been allocated with
7642  *	cfg80211_testmode_alloc_reply_skb()
7643  *
7644  * Since calling this function will usually be the last thing
7645  * before returning from the @testmode_cmd you should return
7646  * the error code.  Note that this function consumes the skb
7647  * regardless of the return value.
7648  *
7649  * Return: An error code or 0 on success.
7650  */
cfg80211_testmode_reply(struct sk_buff * skb)7651 static inline int cfg80211_testmode_reply(struct sk_buff *skb)
7652 {
7653 	return cfg80211_vendor_cmd_reply(skb);
7654 }
7655 
7656 /**
7657  * cfg80211_testmode_alloc_event_skb - allocate testmode event
7658  * @wiphy: the wiphy
7659  * @approxlen: an upper bound of the length of the data that will
7660  *	be put into the skb
7661  * @gfp: allocation flags
7662  *
7663  * This function allocates and pre-fills an skb for an event on the
7664  * testmode multicast group.
7665  *
7666  * The returned skb is set up in the same way as with
7667  * cfg80211_testmode_alloc_reply_skb() but prepared for an event. As
7668  * there, you should simply add data to it that will then end up in the
7669  * %NL80211_ATTR_TESTDATA attribute. Again, you must not modify the skb
7670  * in any other way.
7671  *
7672  * When done filling the skb, call cfg80211_testmode_event() with the
7673  * skb to send the event.
7674  *
7675  * Return: An allocated and pre-filled skb. %NULL if any errors happen.
7676  */
7677 static inline struct sk_buff *
cfg80211_testmode_alloc_event_skb(struct wiphy * wiphy,int approxlen,gfp_t gfp)7678 cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy, int approxlen, gfp_t gfp)
7679 {
7680 	return __cfg80211_alloc_event_skb(wiphy, NULL, NL80211_CMD_TESTMODE,
7681 					  NL80211_ATTR_TESTDATA, 0, -1,
7682 					  approxlen, gfp);
7683 }
7684 
7685 /**
7686  * cfg80211_testmode_event - send the event
7687  * @skb: The skb, must have been allocated with
7688  *	cfg80211_testmode_alloc_event_skb()
7689  * @gfp: allocation flags
7690  *
7691  * This function sends the given @skb, which must have been allocated
7692  * by cfg80211_testmode_alloc_event_skb(), as an event. It always
7693  * consumes it.
7694  */
cfg80211_testmode_event(struct sk_buff * skb,gfp_t gfp)7695 static inline void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
7696 {
7697 	__cfg80211_send_event_skb(skb, gfp);
7698 }
7699 
7700 #define CFG80211_TESTMODE_CMD(cmd)	.testmode_cmd = (cmd),
7701 #define CFG80211_TESTMODE_DUMP(cmd)	.testmode_dump = (cmd),
7702 #else
7703 #define CFG80211_TESTMODE_CMD(cmd)
7704 #define CFG80211_TESTMODE_DUMP(cmd)
7705 #endif
7706 
7707 /**
7708  * struct cfg80211_fils_resp_params - FILS connection response params
7709  * @kek: KEK derived from a successful FILS connection (may be %NULL)
7710  * @kek_len: Length of @fils_kek in octets
7711  * @update_erp_next_seq_num: Boolean value to specify whether the value in
7712  *	@erp_next_seq_num is valid.
7713  * @erp_next_seq_num: The next sequence number to use in ERP message in
7714  *	FILS Authentication. This value should be specified irrespective of the
7715  *	status for a FILS connection.
7716  * @pmk: A new PMK if derived from a successful FILS connection (may be %NULL).
7717  * @pmk_len: Length of @pmk in octets
7718  * @pmkid: A new PMKID if derived from a successful FILS connection or the PMKID
7719  *	used for this FILS connection (may be %NULL).
7720  */
7721 struct cfg80211_fils_resp_params {
7722 	const u8 *kek;
7723 	size_t kek_len;
7724 	bool update_erp_next_seq_num;
7725 	u16 erp_next_seq_num;
7726 	const u8 *pmk;
7727 	size_t pmk_len;
7728 	const u8 *pmkid;
7729 };
7730 
7731 /**
7732  * struct cfg80211_connect_resp_params - Connection response params
7733  * @status: Status code, %WLAN_STATUS_SUCCESS for successful connection, use
7734  *	%WLAN_STATUS_UNSPECIFIED_FAILURE if your device cannot give you
7735  *	the real status code for failures. If this call is used to report a
7736  *	failure due to a timeout (e.g., not receiving an Authentication frame
7737  *	from the AP) instead of an explicit rejection by the AP, -1 is used to
7738  *	indicate that this is a failure, but without a status code.
7739  *	@timeout_reason is used to report the reason for the timeout in that
7740  *	case.
7741  * @req_ie: Association request IEs (may be %NULL)
7742  * @req_ie_len: Association request IEs length
7743  * @resp_ie: Association response IEs (may be %NULL)
7744  * @resp_ie_len: Association response IEs length
7745  * @fils: FILS connection response parameters.
7746  * @timeout_reason: Reason for connection timeout. This is used when the
7747  *	connection fails due to a timeout instead of an explicit rejection from
7748  *	the AP. %NL80211_TIMEOUT_UNSPECIFIED is used when the timeout reason is
7749  *	not known. This value is used only if @status < 0 to indicate that the
7750  *	failure is due to a timeout and not due to explicit rejection by the AP.
7751  *	This value is ignored in other cases (@status >= 0).
7752  * @valid_links: For MLO connection, BIT mask of the valid link ids. Otherwise
7753  *	zero.
7754  * @ap_mld_addr: For MLO connection, MLD address of the AP. Otherwise %NULL.
7755  * @links : For MLO connection, contains link info for the valid links indicated
7756  *	using @valid_links. For non-MLO connection, links[0] contains the
7757  *	connected AP info.
7758  * @links.addr: For MLO connection, MAC address of the STA link. Otherwise
7759  *	%NULL.
7760  * @links.bssid: For MLO connection, MAC address of the AP link. For non-MLO
7761  *	connection, links[0].bssid points to the BSSID of the AP (may be %NULL).
7762  * @links.bss: For MLO connection, entry of bss to which STA link is connected.
7763  *	For non-MLO connection, links[0].bss points to entry of bss to which STA
7764  *	is connected. It can be obtained through cfg80211_get_bss() (may be
7765  *	%NULL). It is recommended to store the bss from the connect_request and
7766  *	hold a reference to it and return through this param to avoid a warning
7767  *	if the bss is expired during the connection, esp. for those drivers
7768  *	implementing connect op. Only one parameter among @bssid and @bss needs
7769  *	to be specified.
7770  * @links.status: per-link status code, to report a status code that's not
7771  *	%WLAN_STATUS_SUCCESS for a given link, it must also be in the
7772  *	@valid_links bitmap and may have a BSS pointer (which is then released)
7773  */
7774 struct cfg80211_connect_resp_params {
7775 	int status;
7776 	const u8 *req_ie;
7777 	size_t req_ie_len;
7778 	const u8 *resp_ie;
7779 	size_t resp_ie_len;
7780 	struct cfg80211_fils_resp_params fils;
7781 	enum nl80211_timeout_reason timeout_reason;
7782 
7783 	const u8 *ap_mld_addr;
7784 	u16 valid_links;
7785 	struct {
7786 		const u8 *addr;
7787 		const u8 *bssid;
7788 		struct cfg80211_bss *bss;
7789 		u16 status;
7790 	} links[IEEE80211_MLD_MAX_NUM_LINKS];
7791 };
7792 
7793 /**
7794  * cfg80211_connect_done - notify cfg80211 of connection result
7795  *
7796  * @dev: network device
7797  * @params: connection response parameters
7798  * @gfp: allocation flags
7799  *
7800  * It should be called by the underlying driver once execution of the connection
7801  * request from connect() has been completed. This is similar to
7802  * cfg80211_connect_bss(), but takes a structure pointer for connection response
7803  * parameters. Only one of the functions among cfg80211_connect_bss(),
7804  * cfg80211_connect_result(), cfg80211_connect_timeout(),
7805  * and cfg80211_connect_done() should be called.
7806  */
7807 void cfg80211_connect_done(struct net_device *dev,
7808 			   struct cfg80211_connect_resp_params *params,
7809 			   gfp_t gfp);
7810 
7811 /**
7812  * cfg80211_connect_bss - notify cfg80211 of connection result
7813  *
7814  * @dev: network device
7815  * @bssid: the BSSID of the AP
7816  * @bss: Entry of bss to which STA got connected to, can be obtained through
7817  *	cfg80211_get_bss() (may be %NULL). But it is recommended to store the
7818  *	bss from the connect_request and hold a reference to it and return
7819  *	through this param to avoid a warning if the bss is expired during the
7820  *	connection, esp. for those drivers implementing connect op.
7821  *	Only one parameter among @bssid and @bss needs to be specified.
7822  * @req_ie: association request IEs (maybe be %NULL)
7823  * @req_ie_len: association request IEs length
7824  * @resp_ie: association response IEs (may be %NULL)
7825  * @resp_ie_len: assoc response IEs length
7826  * @status: status code, %WLAN_STATUS_SUCCESS for successful connection, use
7827  *	%WLAN_STATUS_UNSPECIFIED_FAILURE if your device cannot give you
7828  *	the real status code for failures. If this call is used to report a
7829  *	failure due to a timeout (e.g., not receiving an Authentication frame
7830  *	from the AP) instead of an explicit rejection by the AP, -1 is used to
7831  *	indicate that this is a failure, but without a status code.
7832  *	@timeout_reason is used to report the reason for the timeout in that
7833  *	case.
7834  * @gfp: allocation flags
7835  * @timeout_reason: reason for connection timeout. This is used when the
7836  *	connection fails due to a timeout instead of an explicit rejection from
7837  *	the AP. %NL80211_TIMEOUT_UNSPECIFIED is used when the timeout reason is
7838  *	not known. This value is used only if @status < 0 to indicate that the
7839  *	failure is due to a timeout and not due to explicit rejection by the AP.
7840  *	This value is ignored in other cases (@status >= 0).
7841  *
7842  * It should be called by the underlying driver once execution of the connection
7843  * request from connect() has been completed. This is similar to
7844  * cfg80211_connect_result(), but with the option of identifying the exact bss
7845  * entry for the connection. Only one of the functions among
7846  * cfg80211_connect_bss(), cfg80211_connect_result(),
7847  * cfg80211_connect_timeout(), and cfg80211_connect_done() should be called.
7848  */
7849 static inline void
cfg80211_connect_bss(struct net_device * dev,const u8 * bssid,struct cfg80211_bss * bss,const u8 * req_ie,size_t req_ie_len,const u8 * resp_ie,size_t resp_ie_len,int status,gfp_t gfp,enum nl80211_timeout_reason timeout_reason)7850 cfg80211_connect_bss(struct net_device *dev, const u8 *bssid,
7851 		     struct cfg80211_bss *bss, const u8 *req_ie,
7852 		     size_t req_ie_len, const u8 *resp_ie,
7853 		     size_t resp_ie_len, int status, gfp_t gfp,
7854 		     enum nl80211_timeout_reason timeout_reason)
7855 {
7856 	struct cfg80211_connect_resp_params params;
7857 
7858 	memset(&params, 0, sizeof(params));
7859 	params.status = status;
7860 	params.links[0].bssid = bssid;
7861 	params.links[0].bss = bss;
7862 	params.req_ie = req_ie;
7863 	params.req_ie_len = req_ie_len;
7864 	params.resp_ie = resp_ie;
7865 	params.resp_ie_len = resp_ie_len;
7866 	params.timeout_reason = timeout_reason;
7867 
7868 	cfg80211_connect_done(dev, &params, gfp);
7869 }
7870 
7871 /**
7872  * cfg80211_connect_result - notify cfg80211 of connection result
7873  *
7874  * @dev: network device
7875  * @bssid: the BSSID of the AP
7876  * @req_ie: association request IEs (maybe be %NULL)
7877  * @req_ie_len: association request IEs length
7878  * @resp_ie: association response IEs (may be %NULL)
7879  * @resp_ie_len: assoc response IEs length
7880  * @status: status code, %WLAN_STATUS_SUCCESS for successful connection, use
7881  *	%WLAN_STATUS_UNSPECIFIED_FAILURE if your device cannot give you
7882  *	the real status code for failures.
7883  * @gfp: allocation flags
7884  *
7885  * It should be called by the underlying driver once execution of the connection
7886  * request from connect() has been completed. This is similar to
7887  * cfg80211_connect_bss() which allows the exact bss entry to be specified. Only
7888  * one of the functions among cfg80211_connect_bss(), cfg80211_connect_result(),
7889  * cfg80211_connect_timeout(), and cfg80211_connect_done() should be called.
7890  */
7891 static inline void
cfg80211_connect_result(struct net_device * dev,const u8 * bssid,const u8 * req_ie,size_t req_ie_len,const u8 * resp_ie,size_t resp_ie_len,u16 status,gfp_t gfp)7892 cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
7893 			const u8 *req_ie, size_t req_ie_len,
7894 			const u8 *resp_ie, size_t resp_ie_len,
7895 			u16 status, gfp_t gfp)
7896 {
7897 	cfg80211_connect_bss(dev, bssid, NULL, req_ie, req_ie_len, resp_ie,
7898 			     resp_ie_len, status, gfp,
7899 			     NL80211_TIMEOUT_UNSPECIFIED);
7900 }
7901 
7902 /**
7903  * cfg80211_connect_timeout - notify cfg80211 of connection timeout
7904  *
7905  * @dev: network device
7906  * @bssid: the BSSID of the AP
7907  * @req_ie: association request IEs (maybe be %NULL)
7908  * @req_ie_len: association request IEs length
7909  * @gfp: allocation flags
7910  * @timeout_reason: reason for connection timeout.
7911  *
7912  * It should be called by the underlying driver whenever connect() has failed
7913  * in a sequence where no explicit authentication/association rejection was
7914  * received from the AP. This could happen, e.g., due to not being able to send
7915  * out the Authentication or Association Request frame or timing out while
7916  * waiting for the response. Only one of the functions among
7917  * cfg80211_connect_bss(), cfg80211_connect_result(),
7918  * cfg80211_connect_timeout(), and cfg80211_connect_done() should be called.
7919  */
7920 static inline void
cfg80211_connect_timeout(struct net_device * dev,const u8 * bssid,const u8 * req_ie,size_t req_ie_len,gfp_t gfp,enum nl80211_timeout_reason timeout_reason)7921 cfg80211_connect_timeout(struct net_device *dev, const u8 *bssid,
7922 			 const u8 *req_ie, size_t req_ie_len, gfp_t gfp,
7923 			 enum nl80211_timeout_reason timeout_reason)
7924 {
7925 	cfg80211_connect_bss(dev, bssid, NULL, req_ie, req_ie_len, NULL, 0, -1,
7926 			     gfp, timeout_reason);
7927 }
7928 
7929 /**
7930  * struct cfg80211_roam_info - driver initiated roaming information
7931  *
7932  * @req_ie: association request IEs (maybe be %NULL)
7933  * @req_ie_len: association request IEs length
7934  * @resp_ie: association response IEs (may be %NULL)
7935  * @resp_ie_len: assoc response IEs length
7936  * @fils: FILS related roaming information.
7937  * @valid_links: For MLO roaming, BIT mask of the new valid links is set.
7938  *	Otherwise zero.
7939  * @ap_mld_addr: For MLO roaming, MLD address of the new AP. Otherwise %NULL.
7940  * @links : For MLO roaming, contains new link info for the valid links set in
7941  *	@valid_links. For non-MLO roaming, links[0] contains the new AP info.
7942  * @links.addr: For MLO roaming, MAC address of the STA link. Otherwise %NULL.
7943  * @links.bssid: For MLO roaming, MAC address of the new AP link. For non-MLO
7944  *	roaming, links[0].bssid points to the BSSID of the new AP. May be
7945  *	%NULL if %links.bss is set.
7946  * @links.channel: the channel of the new AP.
7947  * @links.bss: For MLO roaming, entry of new bss to which STA link got
7948  *	roamed. For non-MLO roaming, links[0].bss points to entry of bss to
7949  *	which STA got roamed (may be %NULL if %links.bssid is set)
7950  */
7951 struct cfg80211_roam_info {
7952 	const u8 *req_ie;
7953 	size_t req_ie_len;
7954 	const u8 *resp_ie;
7955 	size_t resp_ie_len;
7956 	struct cfg80211_fils_resp_params fils;
7957 
7958 	const u8 *ap_mld_addr;
7959 	u16 valid_links;
7960 	struct {
7961 		const u8 *addr;
7962 		const u8 *bssid;
7963 		struct ieee80211_channel *channel;
7964 		struct cfg80211_bss *bss;
7965 	} links[IEEE80211_MLD_MAX_NUM_LINKS];
7966 };
7967 
7968 /**
7969  * cfg80211_roamed - notify cfg80211 of roaming
7970  *
7971  * @dev: network device
7972  * @info: information about the new BSS. struct &cfg80211_roam_info.
7973  * @gfp: allocation flags
7974  *
7975  * This function may be called with the driver passing either the BSSID of the
7976  * new AP or passing the bss entry to avoid a race in timeout of the bss entry.
7977  * It should be called by the underlying driver whenever it roamed from one AP
7978  * to another while connected. Drivers which have roaming implemented in
7979  * firmware should pass the bss entry to avoid a race in bss entry timeout where
7980  * the bss entry of the new AP is seen in the driver, but gets timed out by the
7981  * time it is accessed in __cfg80211_roamed() due to delay in scheduling
7982  * rdev->event_work. In case of any failures, the reference is released
7983  * either in cfg80211_roamed() or in __cfg80211_romed(), Otherwise, it will be
7984  * released while disconnecting from the current bss.
7985  */
7986 void cfg80211_roamed(struct net_device *dev, struct cfg80211_roam_info *info,
7987 		     gfp_t gfp);
7988 
7989 /**
7990  * cfg80211_port_authorized - notify cfg80211 of successful security association
7991  *
7992  * @dev: network device
7993  * @bssid: the BSSID of the AP
7994  * @td_bitmap: transition disable policy
7995  * @td_bitmap_len: Length of transition disable policy
7996  * @gfp: allocation flags
7997  *
7998  * This function should be called by a driver that supports 4 way handshake
7999  * offload after a security association was successfully established (i.e.,
8000  * the 4 way handshake was completed successfully). The call to this function
8001  * should be preceded with a call to cfg80211_connect_result(),
8002  * cfg80211_connect_done(), cfg80211_connect_bss() or cfg80211_roamed() to
8003  * indicate the 802.11 association.
8004  */
8005 void cfg80211_port_authorized(struct net_device *dev, const u8 *bssid,
8006 			      const u8* td_bitmap, u8 td_bitmap_len, gfp_t gfp);
8007 
8008 /**
8009  * cfg80211_disconnected - notify cfg80211 that connection was dropped
8010  *
8011  * @dev: network device
8012  * @ie: information elements of the deauth/disassoc frame (may be %NULL)
8013  * @ie_len: length of IEs
8014  * @reason: reason code for the disconnection, set it to 0 if unknown
8015  * @locally_generated: disconnection was requested locally
8016  * @gfp: allocation flags
8017  *
8018  * After it calls this function, the driver should enter an idle state
8019  * and not try to connect to any AP any more.
8020  */
8021 void cfg80211_disconnected(struct net_device *dev, u16 reason,
8022 			   const u8 *ie, size_t ie_len,
8023 			   bool locally_generated, gfp_t gfp);
8024 
8025 /**
8026  * cfg80211_ready_on_channel - notification of remain_on_channel start
8027  * @wdev: wireless device
8028  * @cookie: the request cookie
8029  * @chan: The current channel (from remain_on_channel request)
8030  * @duration: Duration in milliseconds that the driver intents to remain on the
8031  *	channel
8032  * @gfp: allocation flags
8033  */
8034 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
8035 			       struct ieee80211_channel *chan,
8036 			       unsigned int duration, gfp_t gfp);
8037 
8038 /**
8039  * cfg80211_remain_on_channel_expired - remain_on_channel duration expired
8040  * @wdev: wireless device
8041  * @cookie: the request cookie
8042  * @chan: The current channel (from remain_on_channel request)
8043  * @gfp: allocation flags
8044  */
8045 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
8046 					struct ieee80211_channel *chan,
8047 					gfp_t gfp);
8048 
8049 /**
8050  * cfg80211_tx_mgmt_expired - tx_mgmt duration expired
8051  * @wdev: wireless device
8052  * @cookie: the requested cookie
8053  * @chan: The current channel (from tx_mgmt request)
8054  * @gfp: allocation flags
8055  */
8056 void cfg80211_tx_mgmt_expired(struct wireless_dev *wdev, u64 cookie,
8057 			      struct ieee80211_channel *chan, gfp_t gfp);
8058 
8059 /**
8060  * cfg80211_sinfo_alloc_tid_stats - allocate per-tid statistics.
8061  *
8062  * @sinfo: the station information
8063  * @gfp: allocation flags
8064  */
8065 int cfg80211_sinfo_alloc_tid_stats(struct station_info *sinfo, gfp_t gfp);
8066 
8067 /**
8068  * cfg80211_sinfo_release_content - release contents of station info
8069  * @sinfo: the station information
8070  *
8071  * Releases any potentially allocated sub-information of the station
8072  * information, but not the struct itself (since it's typically on
8073  * the stack.)
8074  */
cfg80211_sinfo_release_content(struct station_info * sinfo)8075 static inline void cfg80211_sinfo_release_content(struct station_info *sinfo)
8076 {
8077 	kfree(sinfo->pertid);
8078 }
8079 
8080 /**
8081  * cfg80211_new_sta - notify userspace about station
8082  *
8083  * @dev: the netdev
8084  * @mac_addr: the station's address
8085  * @sinfo: the station information
8086  * @gfp: allocation flags
8087  */
8088 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
8089 		      struct station_info *sinfo, gfp_t gfp);
8090 
8091 /**
8092  * cfg80211_del_sta_sinfo - notify userspace about deletion of a station
8093  * @dev: the netdev
8094  * @mac_addr: the station's address. For MLD station, MLD address is used.
8095  * @sinfo: the station information/statistics
8096  * @gfp: allocation flags
8097  */
8098 void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
8099 			    struct station_info *sinfo, gfp_t gfp);
8100 
8101 /**
8102  * cfg80211_del_sta - notify userspace about deletion of a station
8103  *
8104  * @dev: the netdev
8105  * @mac_addr: the station's address. For MLD station, MLD address is used.
8106  * @gfp: allocation flags
8107  */
cfg80211_del_sta(struct net_device * dev,const u8 * mac_addr,gfp_t gfp)8108 static inline void cfg80211_del_sta(struct net_device *dev,
8109 				    const u8 *mac_addr, gfp_t gfp)
8110 {
8111 	cfg80211_del_sta_sinfo(dev, mac_addr, NULL, gfp);
8112 }
8113 
8114 /**
8115  * cfg80211_conn_failed - connection request failed notification
8116  *
8117  * @dev: the netdev
8118  * @mac_addr: the station's address
8119  * @reason: the reason for connection failure
8120  * @gfp: allocation flags
8121  *
8122  * Whenever a station tries to connect to an AP and if the station
8123  * could not connect to the AP as the AP has rejected the connection
8124  * for some reasons, this function is called.
8125  *
8126  * The reason for connection failure can be any of the value from
8127  * nl80211_connect_failed_reason enum
8128  */
8129 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
8130 			  enum nl80211_connect_failed_reason reason,
8131 			  gfp_t gfp);
8132 
8133 /**
8134  * struct cfg80211_rx_info - received management frame info
8135  *
8136  * @freq: Frequency on which the frame was received in kHz
8137  * @sig_dbm: signal strength in dBm, or 0 if unknown
8138  * @have_link_id: indicates the frame was received on a link of
8139  *	an MLD, i.e. the @link_id field is valid
8140  * @link_id: the ID of the link the frame was received	on
8141  * @buf: Management frame (header + body)
8142  * @len: length of the frame data
8143  * @flags: flags, as defined in &enum nl80211_rxmgmt_flags
8144  * @rx_tstamp: Hardware timestamp of frame RX in nanoseconds
8145  * @ack_tstamp: Hardware timestamp of ack TX in nanoseconds
8146  */
8147 struct cfg80211_rx_info {
8148 	int freq;
8149 	int sig_dbm;
8150 	bool have_link_id;
8151 	u8 link_id;
8152 	const u8 *buf;
8153 	size_t len;
8154 	u32 flags;
8155 	u64 rx_tstamp;
8156 	u64 ack_tstamp;
8157 };
8158 
8159 /**
8160  * cfg80211_rx_mgmt_ext - management frame notification with extended info
8161  * @wdev: wireless device receiving the frame
8162  * @info: RX info as defined in struct cfg80211_rx_info
8163  *
8164  * This function is called whenever an Action frame is received for a station
8165  * mode interface, but is not processed in kernel.
8166  *
8167  * Return: %true if a user space application has registered for this frame.
8168  * For action frames, that makes it responsible for rejecting unrecognized
8169  * action frames; %false otherwise, in which case for action frames the
8170  * driver is responsible for rejecting the frame.
8171  */
8172 bool cfg80211_rx_mgmt_ext(struct wireless_dev *wdev,
8173 			  struct cfg80211_rx_info *info);
8174 
8175 /**
8176  * cfg80211_rx_mgmt_khz - notification of received, unprocessed management frame
8177  * @wdev: wireless device receiving the frame
8178  * @freq: Frequency on which the frame was received in KHz
8179  * @sig_dbm: signal strength in dBm, or 0 if unknown
8180  * @buf: Management frame (header + body)
8181  * @len: length of the frame data
8182  * @flags: flags, as defined in enum nl80211_rxmgmt_flags
8183  *
8184  * This function is called whenever an Action frame is received for a station
8185  * mode interface, but is not processed in kernel.
8186  *
8187  * Return: %true if a user space application has registered for this frame.
8188  * For action frames, that makes it responsible for rejecting unrecognized
8189  * action frames; %false otherwise, in which case for action frames the
8190  * driver is responsible for rejecting the frame.
8191  */
cfg80211_rx_mgmt_khz(struct wireless_dev * wdev,int freq,int sig_dbm,const u8 * buf,size_t len,u32 flags)8192 static inline bool cfg80211_rx_mgmt_khz(struct wireless_dev *wdev, int freq,
8193 					int sig_dbm, const u8 *buf, size_t len,
8194 					u32 flags)
8195 {
8196 	struct cfg80211_rx_info info = {
8197 		.freq = freq,
8198 		.sig_dbm = sig_dbm,
8199 		.buf = buf,
8200 		.len = len,
8201 		.flags = flags
8202 	};
8203 
8204 	return cfg80211_rx_mgmt_ext(wdev, &info);
8205 }
8206 
8207 /**
8208  * cfg80211_rx_mgmt - notification of received, unprocessed management frame
8209  * @wdev: wireless device receiving the frame
8210  * @freq: Frequency on which the frame was received in MHz
8211  * @sig_dbm: signal strength in dBm, or 0 if unknown
8212  * @buf: Management frame (header + body)
8213  * @len: length of the frame data
8214  * @flags: flags, as defined in enum nl80211_rxmgmt_flags
8215  *
8216  * This function is called whenever an Action frame is received for a station
8217  * mode interface, but is not processed in kernel.
8218  *
8219  * Return: %true if a user space application has registered for this frame.
8220  * For action frames, that makes it responsible for rejecting unrecognized
8221  * action frames; %false otherwise, in which case for action frames the
8222  * driver is responsible for rejecting the frame.
8223  */
cfg80211_rx_mgmt(struct wireless_dev * wdev,int freq,int sig_dbm,const u8 * buf,size_t len,u32 flags)8224 static inline bool cfg80211_rx_mgmt(struct wireless_dev *wdev, int freq,
8225 				    int sig_dbm, const u8 *buf, size_t len,
8226 				    u32 flags)
8227 {
8228 	struct cfg80211_rx_info info = {
8229 		.freq = MHZ_TO_KHZ(freq),
8230 		.sig_dbm = sig_dbm,
8231 		.buf = buf,
8232 		.len = len,
8233 		.flags = flags
8234 	};
8235 
8236 	return cfg80211_rx_mgmt_ext(wdev, &info);
8237 }
8238 
8239 /**
8240  * struct cfg80211_tx_status - TX status for management frame information
8241  *
8242  * @cookie: Cookie returned by cfg80211_ops::mgmt_tx()
8243  * @tx_tstamp: hardware TX timestamp in nanoseconds
8244  * @ack_tstamp: hardware ack RX timestamp in nanoseconds
8245  * @buf: Management frame (header + body)
8246  * @len: length of the frame data
8247  * @ack: Whether frame was acknowledged
8248  */
8249 struct cfg80211_tx_status {
8250 	u64 cookie;
8251 	u64 tx_tstamp;
8252 	u64 ack_tstamp;
8253 	const u8 *buf;
8254 	size_t len;
8255 	bool ack;
8256 };
8257 
8258 /**
8259  * cfg80211_mgmt_tx_status_ext - TX status notification with extended info
8260  * @wdev: wireless device receiving the frame
8261  * @status: TX status data
8262  * @gfp: context flags
8263  *
8264  * This function is called whenever a management frame was requested to be
8265  * transmitted with cfg80211_ops::mgmt_tx() to report the TX status of the
8266  * transmission attempt with extended info.
8267  */
8268 void cfg80211_mgmt_tx_status_ext(struct wireless_dev *wdev,
8269 				 struct cfg80211_tx_status *status, gfp_t gfp);
8270 
8271 /**
8272  * cfg80211_mgmt_tx_status - notification of TX status for management frame
8273  * @wdev: wireless device receiving the frame
8274  * @cookie: Cookie returned by cfg80211_ops::mgmt_tx()
8275  * @buf: Management frame (header + body)
8276  * @len: length of the frame data
8277  * @ack: Whether frame was acknowledged
8278  * @gfp: context flags
8279  *
8280  * This function is called whenever a management frame was requested to be
8281  * transmitted with cfg80211_ops::mgmt_tx() to report the TX status of the
8282  * transmission attempt.
8283  */
cfg80211_mgmt_tx_status(struct wireless_dev * wdev,u64 cookie,const u8 * buf,size_t len,bool ack,gfp_t gfp)8284 static inline void cfg80211_mgmt_tx_status(struct wireless_dev *wdev,
8285 					   u64 cookie, const u8 *buf,
8286 					   size_t len, bool ack, gfp_t gfp)
8287 {
8288 	struct cfg80211_tx_status status = {
8289 		.cookie = cookie,
8290 		.buf = buf,
8291 		.len = len,
8292 		.ack = ack
8293 	};
8294 
8295 	cfg80211_mgmt_tx_status_ext(wdev, &status, gfp);
8296 }
8297 
8298 /**
8299  * cfg80211_control_port_tx_status - notification of TX status for control
8300  *                                   port frames
8301  * @wdev: wireless device receiving the frame
8302  * @cookie: Cookie returned by cfg80211_ops::tx_control_port()
8303  * @buf: Data frame (header + body)
8304  * @len: length of the frame data
8305  * @ack: Whether frame was acknowledged
8306  * @gfp: context flags
8307  *
8308  * This function is called whenever a control port frame was requested to be
8309  * transmitted with cfg80211_ops::tx_control_port() to report the TX status of
8310  * the transmission attempt.
8311  */
8312 void cfg80211_control_port_tx_status(struct wireless_dev *wdev, u64 cookie,
8313 				     const u8 *buf, size_t len, bool ack,
8314 				     gfp_t gfp);
8315 
8316 /**
8317  * cfg80211_rx_control_port - notification about a received control port frame
8318  * @dev: The device the frame matched to
8319  * @skb: The skbuf with the control port frame.  It is assumed that the skbuf
8320  *	is 802.3 formatted (with 802.3 header).  The skb can be non-linear.
8321  *	This function does not take ownership of the skb, so the caller is
8322  *	responsible for any cleanup.  The caller must also ensure that
8323  *	skb->protocol is set appropriately.
8324  * @unencrypted: Whether the frame was received unencrypted
8325  * @link_id: the link the frame was received on, -1 if not applicable or unknown
8326  *
8327  * This function is used to inform userspace about a received control port
8328  * frame.  It should only be used if userspace indicated it wants to receive
8329  * control port frames over nl80211.
8330  *
8331  * The frame is the data portion of the 802.3 or 802.11 data frame with all
8332  * network layer headers removed (e.g. the raw EAPoL frame).
8333  *
8334  * Return: %true if the frame was passed to userspace
8335  */
8336 bool cfg80211_rx_control_port(struct net_device *dev, struct sk_buff *skb,
8337 			      bool unencrypted, int link_id);
8338 
8339 /**
8340  * cfg80211_cqm_rssi_notify - connection quality monitoring rssi event
8341  * @dev: network device
8342  * @rssi_event: the triggered RSSI event
8343  * @rssi_level: new RSSI level value or 0 if not available
8344  * @gfp: context flags
8345  *
8346  * This function is called when a configured connection quality monitoring
8347  * rssi threshold reached event occurs.
8348  */
8349 void cfg80211_cqm_rssi_notify(struct net_device *dev,
8350 			      enum nl80211_cqm_rssi_threshold_event rssi_event,
8351 			      s32 rssi_level, gfp_t gfp);
8352 
8353 /**
8354  * cfg80211_cqm_pktloss_notify - notify userspace about packetloss to peer
8355  * @dev: network device
8356  * @peer: peer's MAC address
8357  * @num_packets: how many packets were lost -- should be a fixed threshold
8358  *	but probably no less than maybe 50, or maybe a throughput dependent
8359  *	threshold (to account for temporary interference)
8360  * @gfp: context flags
8361  */
8362 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
8363 				 const u8 *peer, u32 num_packets, gfp_t gfp);
8364 
8365 /**
8366  * cfg80211_cqm_txe_notify - TX error rate event
8367  * @dev: network device
8368  * @peer: peer's MAC address
8369  * @num_packets: how many packets were lost
8370  * @rate: % of packets which failed transmission
8371  * @intvl: interval (in s) over which the TX failure threshold was breached.
8372  * @gfp: context flags
8373  *
8374  * Notify userspace when configured % TX failures over number of packets in a
8375  * given interval is exceeded.
8376  */
8377 void cfg80211_cqm_txe_notify(struct net_device *dev, const u8 *peer,
8378 			     u32 num_packets, u32 rate, u32 intvl, gfp_t gfp);
8379 
8380 /**
8381  * cfg80211_cqm_beacon_loss_notify - beacon loss event
8382  * @dev: network device
8383  * @gfp: context flags
8384  *
8385  * Notify userspace about beacon loss from the connected AP.
8386  */
8387 void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp);
8388 
8389 /**
8390  * __cfg80211_radar_event - radar detection event
8391  * @wiphy: the wiphy
8392  * @chandef: chandef for the current channel
8393  * @offchan: the radar has been detected on the offchannel chain
8394  * @gfp: context flags
8395  *
8396  * This function is called when a radar is detected on the current chanenl.
8397  */
8398 void __cfg80211_radar_event(struct wiphy *wiphy,
8399 			    struct cfg80211_chan_def *chandef,
8400 			    bool offchan, gfp_t gfp);
8401 
8402 static inline void
cfg80211_radar_event(struct wiphy * wiphy,struct cfg80211_chan_def * chandef,gfp_t gfp)8403 cfg80211_radar_event(struct wiphy *wiphy,
8404 		     struct cfg80211_chan_def *chandef,
8405 		     gfp_t gfp)
8406 {
8407 	__cfg80211_radar_event(wiphy, chandef, false, gfp);
8408 }
8409 
8410 static inline void
cfg80211_background_radar_event(struct wiphy * wiphy,struct cfg80211_chan_def * chandef,gfp_t gfp)8411 cfg80211_background_radar_event(struct wiphy *wiphy,
8412 				struct cfg80211_chan_def *chandef,
8413 				gfp_t gfp)
8414 {
8415 	__cfg80211_radar_event(wiphy, chandef, true, gfp);
8416 }
8417 
8418 /**
8419  * cfg80211_sta_opmode_change_notify - STA's ht/vht operation mode change event
8420  * @dev: network device
8421  * @mac: MAC address of a station which opmode got modified
8422  * @sta_opmode: station's current opmode value
8423  * @gfp: context flags
8424  *
8425  * Driver should call this function when station's opmode modified via action
8426  * frame.
8427  */
8428 void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac,
8429 				       struct sta_opmode_info *sta_opmode,
8430 				       gfp_t gfp);
8431 
8432 /**
8433  * cfg80211_cac_event - Channel availability check (CAC) event
8434  * @netdev: network device
8435  * @chandef: chandef for the current channel
8436  * @event: type of event
8437  * @gfp: context flags
8438  *
8439  * This function is called when a Channel availability check (CAC) is finished
8440  * or aborted. This must be called to notify the completion of a CAC process,
8441  * also by full-MAC drivers.
8442  */
8443 void cfg80211_cac_event(struct net_device *netdev,
8444 			const struct cfg80211_chan_def *chandef,
8445 			enum nl80211_radar_event event, gfp_t gfp);
8446 
8447 /**
8448  * cfg80211_background_cac_abort - Channel Availability Check offchan abort event
8449  * @wiphy: the wiphy
8450  *
8451  * This function is called by the driver when a Channel Availability Check
8452  * (CAC) is aborted by a offchannel dedicated chain.
8453  */
8454 void cfg80211_background_cac_abort(struct wiphy *wiphy);
8455 
8456 /**
8457  * cfg80211_gtk_rekey_notify - notify userspace about driver rekeying
8458  * @dev: network device
8459  * @bssid: BSSID of AP (to avoid races)
8460  * @replay_ctr: new replay counter
8461  * @gfp: allocation flags
8462  */
8463 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
8464 			       const u8 *replay_ctr, gfp_t gfp);
8465 
8466 /**
8467  * cfg80211_pmksa_candidate_notify - notify about PMKSA caching candidate
8468  * @dev: network device
8469  * @index: candidate index (the smaller the index, the higher the priority)
8470  * @bssid: BSSID of AP
8471  * @preauth: Whether AP advertises support for RSN pre-authentication
8472  * @gfp: allocation flags
8473  */
8474 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
8475 				     const u8 *bssid, bool preauth, gfp_t gfp);
8476 
8477 /**
8478  * cfg80211_rx_spurious_frame - inform userspace about a spurious frame
8479  * @dev: The device the frame matched to
8480  * @addr: the transmitter address
8481  * @gfp: context flags
8482  *
8483  * This function is used in AP mode (only!) to inform userspace that
8484  * a spurious class 3 frame was received, to be able to deauth the
8485  * sender.
8486  * Return: %true if the frame was passed to userspace (or this failed
8487  * for a reason other than not having a subscription.)
8488  */
8489 bool cfg80211_rx_spurious_frame(struct net_device *dev,
8490 				const u8 *addr, gfp_t gfp);
8491 
8492 /**
8493  * cfg80211_rx_unexpected_4addr_frame - inform about unexpected WDS frame
8494  * @dev: The device the frame matched to
8495  * @addr: the transmitter address
8496  * @gfp: context flags
8497  *
8498  * This function is used in AP mode (only!) to inform userspace that
8499  * an associated station sent a 4addr frame but that wasn't expected.
8500  * It is allowed and desirable to send this event only once for each
8501  * station to avoid event flooding.
8502  * Return: %true if the frame was passed to userspace (or this failed
8503  * for a reason other than not having a subscription.)
8504  */
8505 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
8506 					const u8 *addr, gfp_t gfp);
8507 
8508 /**
8509  * cfg80211_probe_status - notify userspace about probe status
8510  * @dev: the device the probe was sent on
8511  * @addr: the address of the peer
8512  * @cookie: the cookie filled in @probe_client previously
8513  * @acked: indicates whether probe was acked or not
8514  * @ack_signal: signal strength (in dBm) of the ACK frame.
8515  * @is_valid_ack_signal: indicates the ack_signal is valid or not.
8516  * @gfp: allocation flags
8517  */
8518 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
8519 			   u64 cookie, bool acked, s32 ack_signal,
8520 			   bool is_valid_ack_signal, gfp_t gfp);
8521 
8522 /**
8523  * cfg80211_report_obss_beacon_khz - report beacon from other APs
8524  * @wiphy: The wiphy that received the beacon
8525  * @frame: the frame
8526  * @len: length of the frame
8527  * @freq: frequency the frame was received on in KHz
8528  * @sig_dbm: signal strength in dBm, or 0 if unknown
8529  *
8530  * Use this function to report to userspace when a beacon was
8531  * received. It is not useful to call this when there is no
8532  * netdev that is in AP/GO mode.
8533  */
8534 void cfg80211_report_obss_beacon_khz(struct wiphy *wiphy, const u8 *frame,
8535 				     size_t len, int freq, int sig_dbm);
8536 
8537 /**
8538  * cfg80211_report_obss_beacon - report beacon from other APs
8539  * @wiphy: The wiphy that received the beacon
8540  * @frame: the frame
8541  * @len: length of the frame
8542  * @freq: frequency the frame was received on
8543  * @sig_dbm: signal strength in dBm, or 0 if unknown
8544  *
8545  * Use this function to report to userspace when a beacon was
8546  * received. It is not useful to call this when there is no
8547  * netdev that is in AP/GO mode.
8548  */
cfg80211_report_obss_beacon(struct wiphy * wiphy,const u8 * frame,size_t len,int freq,int sig_dbm)8549 static inline void cfg80211_report_obss_beacon(struct wiphy *wiphy,
8550 					       const u8 *frame, size_t len,
8551 					       int freq, int sig_dbm)
8552 {
8553 	cfg80211_report_obss_beacon_khz(wiphy, frame, len, MHZ_TO_KHZ(freq),
8554 					sig_dbm);
8555 }
8556 
8557 /**
8558  * cfg80211_reg_can_beacon - check if beaconing is allowed
8559  * @wiphy: the wiphy
8560  * @chandef: the channel definition
8561  * @iftype: interface type
8562  *
8563  * Return: %true if there is no secondary channel or the secondary channel(s)
8564  * can be used for beaconing (i.e. is not a radar channel etc.)
8565  */
8566 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
8567 			     struct cfg80211_chan_def *chandef,
8568 			     enum nl80211_iftype iftype);
8569 
8570 /**
8571  * cfg80211_reg_can_beacon_relax - check if beaconing is allowed with relaxation
8572  * @wiphy: the wiphy
8573  * @chandef: the channel definition
8574  * @iftype: interface type
8575  *
8576  * Return: %true if there is no secondary channel or the secondary channel(s)
8577  * can be used for beaconing (i.e. is not a radar channel etc.). This version
8578  * also checks if IR-relaxation conditions apply, to allow beaconing under
8579  * more permissive conditions.
8580  *
8581  * Requires the wiphy mutex to be held.
8582  */
8583 bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
8584 				   struct cfg80211_chan_def *chandef,
8585 				   enum nl80211_iftype iftype);
8586 
8587 /*
8588  * cfg80211_ch_switch_notify - update wdev channel and notify userspace
8589  * @dev: the device which switched channels
8590  * @chandef: the new channel definition
8591  * @link_id: the link ID for MLO, must be 0 for non-MLO
8592  * @punct_bitmap: the new puncturing bitmap
8593  *
8594  * Caller must acquire wdev_lock, therefore must only be called from sleepable
8595  * driver context!
8596  */
8597 void cfg80211_ch_switch_notify(struct net_device *dev,
8598 			       struct cfg80211_chan_def *chandef,
8599 			       unsigned int link_id, u16 punct_bitmap);
8600 
8601 /*
8602  * cfg80211_ch_switch_started_notify - notify channel switch start
8603  * @dev: the device on which the channel switch started
8604  * @chandef: the future channel definition
8605  * @link_id: the link ID for MLO, must be 0 for non-MLO
8606  * @count: the number of TBTTs until the channel switch happens
8607  * @quiet: whether or not immediate quiet was requested by the AP
8608  * @punct_bitmap: the future puncturing bitmap
8609  *
8610  * Inform the userspace about the channel switch that has just
8611  * started, so that it can take appropriate actions (eg. starting
8612  * channel switch on other vifs), if necessary.
8613  */
8614 void cfg80211_ch_switch_started_notify(struct net_device *dev,
8615 				       struct cfg80211_chan_def *chandef,
8616 				       unsigned int link_id, u8 count,
8617 				       bool quiet, u16 punct_bitmap);
8618 
8619 /**
8620  * ieee80211_operating_class_to_band - convert operating class to band
8621  *
8622  * @operating_class: the operating class to convert
8623  * @band: band pointer to fill
8624  *
8625  * Returns %true if the conversion was successful, %false otherwise.
8626  */
8627 bool ieee80211_operating_class_to_band(u8 operating_class,
8628 				       enum nl80211_band *band);
8629 
8630 /**
8631  * ieee80211_chandef_to_operating_class - convert chandef to operation class
8632  *
8633  * @chandef: the chandef to convert
8634  * @op_class: a pointer to the resulting operating class
8635  *
8636  * Returns %true if the conversion was successful, %false otherwise.
8637  */
8638 bool ieee80211_chandef_to_operating_class(struct cfg80211_chan_def *chandef,
8639 					  u8 *op_class);
8640 
8641 /**
8642  * ieee80211_chandef_to_khz - convert chandef to frequency in KHz
8643  *
8644  * @chandef: the chandef to convert
8645  *
8646  * Returns the center frequency of chandef (1st segment) in KHz.
8647  */
8648 static inline u32
ieee80211_chandef_to_khz(const struct cfg80211_chan_def * chandef)8649 ieee80211_chandef_to_khz(const struct cfg80211_chan_def *chandef)
8650 {
8651 	return MHZ_TO_KHZ(chandef->center_freq1) + chandef->freq1_offset;
8652 }
8653 
8654 /*
8655  * cfg80211_tdls_oper_request - request userspace to perform TDLS operation
8656  * @dev: the device on which the operation is requested
8657  * @peer: the MAC address of the peer device
8658  * @oper: the requested TDLS operation (NL80211_TDLS_SETUP or
8659  *	NL80211_TDLS_TEARDOWN)
8660  * @reason_code: the reason code for teardown request
8661  * @gfp: allocation flags
8662  *
8663  * This function is used to request userspace to perform TDLS operation that
8664  * requires knowledge of keys, i.e., link setup or teardown when the AP
8665  * connection uses encryption. This is optional mechanism for the driver to use
8666  * if it can automatically determine when a TDLS link could be useful (e.g.,
8667  * based on traffic and signal strength for a peer).
8668  */
8669 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
8670 				enum nl80211_tdls_operation oper,
8671 				u16 reason_code, gfp_t gfp);
8672 
8673 /*
8674  * cfg80211_calculate_bitrate - calculate actual bitrate (in 100Kbps units)
8675  * @rate: given rate_info to calculate bitrate from
8676  *
8677  * return 0 if MCS index >= 32
8678  */
8679 u32 cfg80211_calculate_bitrate(struct rate_info *rate);
8680 
8681 /**
8682  * cfg80211_unregister_wdev - remove the given wdev
8683  * @wdev: struct wireless_dev to remove
8684  *
8685  * This function removes the device so it can no longer be used. It is necessary
8686  * to call this function even when cfg80211 requests the removal of the device
8687  * by calling the del_virtual_intf() callback. The function must also be called
8688  * when the driver wishes to unregister the wdev, e.g. when the hardware device
8689  * is unbound from the driver.
8690  *
8691  * Requires the RTNL and wiphy mutex to be held.
8692  */
8693 void cfg80211_unregister_wdev(struct wireless_dev *wdev);
8694 
8695 /**
8696  * cfg80211_register_netdevice - register the given netdev
8697  * @dev: the netdev to register
8698  *
8699  * Note: In contexts coming from cfg80211 callbacks, you must call this rather
8700  * than register_netdevice(), unregister_netdev() is impossible as the RTNL is
8701  * held. Otherwise, both register_netdevice() and register_netdev() are usable
8702  * instead as well.
8703  *
8704  * Requires the RTNL and wiphy mutex to be held.
8705  */
8706 int cfg80211_register_netdevice(struct net_device *dev);
8707 
8708 /**
8709  * cfg80211_unregister_netdevice - unregister the given netdev
8710  * @dev: the netdev to register
8711  *
8712  * Note: In contexts coming from cfg80211 callbacks, you must call this rather
8713  * than unregister_netdevice(), unregister_netdev() is impossible as the RTNL
8714  * is held. Otherwise, both unregister_netdevice() and unregister_netdev() are
8715  * usable instead as well.
8716  *
8717  * Requires the RTNL and wiphy mutex to be held.
8718  */
cfg80211_unregister_netdevice(struct net_device * dev)8719 static inline void cfg80211_unregister_netdevice(struct net_device *dev)
8720 {
8721 #if IS_ENABLED(CONFIG_CFG80211)
8722 	cfg80211_unregister_wdev(dev->ieee80211_ptr);
8723 #endif
8724 }
8725 
8726 /**
8727  * struct cfg80211_ft_event_params - FT Information Elements
8728  * @ies: FT IEs
8729  * @ies_len: length of the FT IE in bytes
8730  * @target_ap: target AP's MAC address
8731  * @ric_ies: RIC IE
8732  * @ric_ies_len: length of the RIC IE in bytes
8733  */
8734 struct cfg80211_ft_event_params {
8735 	const u8 *ies;
8736 	size_t ies_len;
8737 	const u8 *target_ap;
8738 	const u8 *ric_ies;
8739 	size_t ric_ies_len;
8740 };
8741 
8742 /**
8743  * cfg80211_ft_event - notify userspace about FT IE and RIC IE
8744  * @netdev: network device
8745  * @ft_event: IE information
8746  */
8747 void cfg80211_ft_event(struct net_device *netdev,
8748 		       struct cfg80211_ft_event_params *ft_event);
8749 
8750 /**
8751  * cfg80211_get_p2p_attr - find and copy a P2P attribute from IE buffer
8752  * @ies: the input IE buffer
8753  * @len: the input length
8754  * @attr: the attribute ID to find
8755  * @buf: output buffer, can be %NULL if the data isn't needed, e.g.
8756  *	if the function is only called to get the needed buffer size
8757  * @bufsize: size of the output buffer
8758  *
8759  * The function finds a given P2P attribute in the (vendor) IEs and
8760  * copies its contents to the given buffer.
8761  *
8762  * Return: A negative error code (-%EILSEQ or -%ENOENT) if the data is
8763  * malformed or the attribute can't be found (respectively), or the
8764  * length of the found attribute (which can be zero).
8765  */
8766 int cfg80211_get_p2p_attr(const u8 *ies, unsigned int len,
8767 			  enum ieee80211_p2p_attr_id attr,
8768 			  u8 *buf, unsigned int bufsize);
8769 
8770 /**
8771  * ieee80211_ie_split_ric - split an IE buffer according to ordering (with RIC)
8772  * @ies: the IE buffer
8773  * @ielen: the length of the IE buffer
8774  * @ids: an array with element IDs that are allowed before
8775  *	the split. A WLAN_EID_EXTENSION value means that the next
8776  *	EID in the list is a sub-element of the EXTENSION IE.
8777  * @n_ids: the size of the element ID array
8778  * @after_ric: array IE types that come after the RIC element
8779  * @n_after_ric: size of the @after_ric array
8780  * @offset: offset where to start splitting in the buffer
8781  *
8782  * This function splits an IE buffer by updating the @offset
8783  * variable to point to the location where the buffer should be
8784  * split.
8785  *
8786  * It assumes that the given IE buffer is well-formed, this
8787  * has to be guaranteed by the caller!
8788  *
8789  * It also assumes that the IEs in the buffer are ordered
8790  * correctly, if not the result of using this function will not
8791  * be ordered correctly either, i.e. it does no reordering.
8792  *
8793  * The function returns the offset where the next part of the
8794  * buffer starts, which may be @ielen if the entire (remainder)
8795  * of the buffer should be used.
8796  */
8797 size_t ieee80211_ie_split_ric(const u8 *ies, size_t ielen,
8798 			      const u8 *ids, int n_ids,
8799 			      const u8 *after_ric, int n_after_ric,
8800 			      size_t offset);
8801 
8802 /**
8803  * ieee80211_ie_split - split an IE buffer according to ordering
8804  * @ies: the IE buffer
8805  * @ielen: the length of the IE buffer
8806  * @ids: an array with element IDs that are allowed before
8807  *	the split. A WLAN_EID_EXTENSION value means that the next
8808  *	EID in the list is a sub-element of the EXTENSION IE.
8809  * @n_ids: the size of the element ID array
8810  * @offset: offset where to start splitting in the buffer
8811  *
8812  * This function splits an IE buffer by updating the @offset
8813  * variable to point to the location where the buffer should be
8814  * split.
8815  *
8816  * It assumes that the given IE buffer is well-formed, this
8817  * has to be guaranteed by the caller!
8818  *
8819  * It also assumes that the IEs in the buffer are ordered
8820  * correctly, if not the result of using this function will not
8821  * be ordered correctly either, i.e. it does no reordering.
8822  *
8823  * The function returns the offset where the next part of the
8824  * buffer starts, which may be @ielen if the entire (remainder)
8825  * of the buffer should be used.
8826  */
ieee80211_ie_split(const u8 * ies,size_t ielen,const u8 * ids,int n_ids,size_t offset)8827 static inline size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
8828 					const u8 *ids, int n_ids, size_t offset)
8829 {
8830 	return ieee80211_ie_split_ric(ies, ielen, ids, n_ids, NULL, 0, offset);
8831 }
8832 
8833 /**
8834  * cfg80211_report_wowlan_wakeup - report wakeup from WoWLAN
8835  * @wdev: the wireless device reporting the wakeup
8836  * @wakeup: the wakeup report
8837  * @gfp: allocation flags
8838  *
8839  * This function reports that the given device woke up. If it
8840  * caused the wakeup, report the reason(s), otherwise you may
8841  * pass %NULL as the @wakeup parameter to advertise that something
8842  * else caused the wakeup.
8843  */
8844 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
8845 				   struct cfg80211_wowlan_wakeup *wakeup,
8846 				   gfp_t gfp);
8847 
8848 /**
8849  * cfg80211_crit_proto_stopped() - indicate critical protocol stopped by driver.
8850  *
8851  * @wdev: the wireless device for which critical protocol is stopped.
8852  * @gfp: allocation flags
8853  *
8854  * This function can be called by the driver to indicate it has reverted
8855  * operation back to normal. One reason could be that the duration given
8856  * by .crit_proto_start() has expired.
8857  */
8858 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp);
8859 
8860 /**
8861  * ieee80211_get_num_supported_channels - get number of channels device has
8862  * @wiphy: the wiphy
8863  *
8864  * Return: the number of channels supported by the device.
8865  */
8866 unsigned int ieee80211_get_num_supported_channels(struct wiphy *wiphy);
8867 
8868 /**
8869  * cfg80211_check_combinations - check interface combinations
8870  *
8871  * @wiphy: the wiphy
8872  * @params: the interface combinations parameter
8873  *
8874  * This function can be called by the driver to check whether a
8875  * combination of interfaces and their types are allowed according to
8876  * the interface combinations.
8877  */
8878 int cfg80211_check_combinations(struct wiphy *wiphy,
8879 				struct iface_combination_params *params);
8880 
8881 /**
8882  * cfg80211_iter_combinations - iterate over matching combinations
8883  *
8884  * @wiphy: the wiphy
8885  * @params: the interface combinations parameter
8886  * @iter: function to call for each matching combination
8887  * @data: pointer to pass to iter function
8888  *
8889  * This function can be called by the driver to check what possible
8890  * combinations it fits in at a given moment, e.g. for channel switching
8891  * purposes.
8892  */
8893 int cfg80211_iter_combinations(struct wiphy *wiphy,
8894 			       struct iface_combination_params *params,
8895 			       void (*iter)(const struct ieee80211_iface_combination *c,
8896 					    void *data),
8897 			       void *data);
8898 
8899 /*
8900  * cfg80211_stop_iface - trigger interface disconnection
8901  *
8902  * @wiphy: the wiphy
8903  * @wdev: wireless device
8904  * @gfp: context flags
8905  *
8906  * Trigger interface to be stopped as if AP was stopped, IBSS/mesh left, STA
8907  * disconnected.
8908  *
8909  * Note: This doesn't need any locks and is asynchronous.
8910  */
8911 void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
8912 			 gfp_t gfp);
8913 
8914 /**
8915  * cfg80211_shutdown_all_interfaces - shut down all interfaces for a wiphy
8916  * @wiphy: the wiphy to shut down
8917  *
8918  * This function shuts down all interfaces belonging to this wiphy by
8919  * calling dev_close() (and treating non-netdev interfaces as needed).
8920  * It shouldn't really be used unless there are some fatal device errors
8921  * that really can't be recovered in any other way.
8922  *
8923  * Callers must hold the RTNL and be able to deal with callbacks into
8924  * the driver while the function is running.
8925  */
8926 void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy);
8927 
8928 /**
8929  * wiphy_ext_feature_set - set the extended feature flag
8930  *
8931  * @wiphy: the wiphy to modify.
8932  * @ftidx: extended feature bit index.
8933  *
8934  * The extended features are flagged in multiple bytes (see
8935  * &struct wiphy.@ext_features)
8936  */
wiphy_ext_feature_set(struct wiphy * wiphy,enum nl80211_ext_feature_index ftidx)8937 static inline void wiphy_ext_feature_set(struct wiphy *wiphy,
8938 					 enum nl80211_ext_feature_index ftidx)
8939 {
8940 	u8 *ft_byte;
8941 
8942 	ft_byte = &wiphy->ext_features[ftidx / 8];
8943 	*ft_byte |= BIT(ftidx % 8);
8944 }
8945 
8946 /**
8947  * wiphy_ext_feature_isset - check the extended feature flag
8948  *
8949  * @wiphy: the wiphy to modify.
8950  * @ftidx: extended feature bit index.
8951  *
8952  * The extended features are flagged in multiple bytes (see
8953  * &struct wiphy.@ext_features)
8954  */
8955 static inline bool
wiphy_ext_feature_isset(struct wiphy * wiphy,enum nl80211_ext_feature_index ftidx)8956 wiphy_ext_feature_isset(struct wiphy *wiphy,
8957 			enum nl80211_ext_feature_index ftidx)
8958 {
8959 	u8 ft_byte;
8960 
8961 	ft_byte = wiphy->ext_features[ftidx / 8];
8962 	return (ft_byte & BIT(ftidx % 8)) != 0;
8963 }
8964 
8965 /**
8966  * cfg80211_free_nan_func - free NAN function
8967  * @f: NAN function that should be freed
8968  *
8969  * Frees all the NAN function and all it's allocated members.
8970  */
8971 void cfg80211_free_nan_func(struct cfg80211_nan_func *f);
8972 
8973 /**
8974  * struct cfg80211_nan_match_params - NAN match parameters
8975  * @type: the type of the function that triggered a match. If it is
8976  *	 %NL80211_NAN_FUNC_SUBSCRIBE it means that we replied to a subscriber.
8977  *	 If it is %NL80211_NAN_FUNC_PUBLISH, it means that we got a discovery
8978  *	 result.
8979  *	 If it is %NL80211_NAN_FUNC_FOLLOW_UP, we received a follow up.
8980  * @inst_id: the local instance id
8981  * @peer_inst_id: the instance id of the peer's function
8982  * @addr: the MAC address of the peer
8983  * @info_len: the length of the &info
8984  * @info: the Service Specific Info from the peer (if any)
8985  * @cookie: unique identifier of the corresponding function
8986  */
8987 struct cfg80211_nan_match_params {
8988 	enum nl80211_nan_function_type type;
8989 	u8 inst_id;
8990 	u8 peer_inst_id;
8991 	const u8 *addr;
8992 	u8 info_len;
8993 	const u8 *info;
8994 	u64 cookie;
8995 };
8996 
8997 /**
8998  * cfg80211_nan_match - report a match for a NAN function.
8999  * @wdev: the wireless device reporting the match
9000  * @match: match notification parameters
9001  * @gfp: allocation flags
9002  *
9003  * This function reports that the a NAN function had a match. This
9004  * can be a subscribe that had a match or a solicited publish that
9005  * was sent. It can also be a follow up that was received.
9006  */
9007 void cfg80211_nan_match(struct wireless_dev *wdev,
9008 			struct cfg80211_nan_match_params *match, gfp_t gfp);
9009 
9010 /**
9011  * cfg80211_nan_func_terminated - notify about NAN function termination.
9012  *
9013  * @wdev: the wireless device reporting the match
9014  * @inst_id: the local instance id
9015  * @reason: termination reason (one of the NL80211_NAN_FUNC_TERM_REASON_*)
9016  * @cookie: unique NAN function identifier
9017  * @gfp: allocation flags
9018  *
9019  * This function reports that the a NAN function is terminated.
9020  */
9021 void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
9022 				  u8 inst_id,
9023 				  enum nl80211_nan_func_term_reason reason,
9024 				  u64 cookie, gfp_t gfp);
9025 
9026 /* ethtool helper */
9027 void cfg80211_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info);
9028 
9029 /**
9030  * cfg80211_external_auth_request - userspace request for authentication
9031  * @netdev: network device
9032  * @params: External authentication parameters
9033  * @gfp: allocation flags
9034  * Returns: 0 on success, < 0 on error
9035  */
9036 int cfg80211_external_auth_request(struct net_device *netdev,
9037 				   struct cfg80211_external_auth_params *params,
9038 				   gfp_t gfp);
9039 
9040 /**
9041  * cfg80211_pmsr_report - report peer measurement result data
9042  * @wdev: the wireless device reporting the measurement
9043  * @req: the original measurement request
9044  * @result: the result data
9045  * @gfp: allocation flags
9046  */
9047 void cfg80211_pmsr_report(struct wireless_dev *wdev,
9048 			  struct cfg80211_pmsr_request *req,
9049 			  struct cfg80211_pmsr_result *result,
9050 			  gfp_t gfp);
9051 
9052 /**
9053  * cfg80211_pmsr_complete - report peer measurement completed
9054  * @wdev: the wireless device reporting the measurement
9055  * @req: the original measurement request
9056  * @gfp: allocation flags
9057  *
9058  * Report that the entire measurement completed, after this
9059  * the request pointer will no longer be valid.
9060  */
9061 void cfg80211_pmsr_complete(struct wireless_dev *wdev,
9062 			    struct cfg80211_pmsr_request *req,
9063 			    gfp_t gfp);
9064 
9065 /**
9066  * cfg80211_iftype_allowed - check whether the interface can be allowed
9067  * @wiphy: the wiphy
9068  * @iftype: interface type
9069  * @is_4addr: use_4addr flag, must be '0' when check_swif is '1'
9070  * @check_swif: check iftype against software interfaces
9071  *
9072  * Check whether the interface is allowed to operate; additionally, this API
9073  * can be used to check iftype against the software interfaces when
9074  * check_swif is '1'.
9075  */
9076 bool cfg80211_iftype_allowed(struct wiphy *wiphy, enum nl80211_iftype iftype,
9077 			     bool is_4addr, u8 check_swif);
9078 
9079 
9080 /**
9081  * cfg80211_assoc_comeback - notification of association that was
9082  * temporarly rejected with a comeback
9083  * @netdev: network device
9084  * @ap_addr: AP (MLD) address that rejected the assocation
9085  * @timeout: timeout interval value TUs.
9086  *
9087  * this function may sleep. the caller must hold the corresponding wdev's mutex.
9088  */
9089 void cfg80211_assoc_comeback(struct net_device *netdev,
9090 			     const u8 *ap_addr, u32 timeout);
9091 
9092 /* Logging, debugging and troubleshooting/diagnostic helpers. */
9093 
9094 /* wiphy_printk helpers, similar to dev_printk */
9095 
9096 #define wiphy_printk(level, wiphy, format, args...)		\
9097 	dev_printk(level, &(wiphy)->dev, format, ##args)
9098 #define wiphy_emerg(wiphy, format, args...)			\
9099 	dev_emerg(&(wiphy)->dev, format, ##args)
9100 #define wiphy_alert(wiphy, format, args...)			\
9101 	dev_alert(&(wiphy)->dev, format, ##args)
9102 #define wiphy_crit(wiphy, format, args...)			\
9103 	dev_crit(&(wiphy)->dev, format, ##args)
9104 #define wiphy_err(wiphy, format, args...)			\
9105 	dev_err(&(wiphy)->dev, format, ##args)
9106 #define wiphy_warn(wiphy, format, args...)			\
9107 	dev_warn(&(wiphy)->dev, format, ##args)
9108 #define wiphy_notice(wiphy, format, args...)			\
9109 	dev_notice(&(wiphy)->dev, format, ##args)
9110 #define wiphy_info(wiphy, format, args...)			\
9111 	dev_info(&(wiphy)->dev, format, ##args)
9112 #define wiphy_info_once(wiphy, format, args...)			\
9113 	dev_info_once(&(wiphy)->dev, format, ##args)
9114 
9115 #define wiphy_err_ratelimited(wiphy, format, args...)		\
9116 	dev_err_ratelimited(&(wiphy)->dev, format, ##args)
9117 #define wiphy_warn_ratelimited(wiphy, format, args...)		\
9118 	dev_warn_ratelimited(&(wiphy)->dev, format, ##args)
9119 
9120 #define wiphy_debug(wiphy, format, args...)			\
9121 	wiphy_printk(KERN_DEBUG, wiphy, format, ##args)
9122 
9123 #define wiphy_dbg(wiphy, format, args...)			\
9124 	dev_dbg(&(wiphy)->dev, format, ##args)
9125 
9126 #if defined(VERBOSE_DEBUG)
9127 #define wiphy_vdbg	wiphy_dbg
9128 #else
9129 #define wiphy_vdbg(wiphy, format, args...)				\
9130 ({									\
9131 	if (0)								\
9132 		wiphy_printk(KERN_DEBUG, wiphy, format, ##args);	\
9133 	0;								\
9134 })
9135 #endif
9136 
9137 /*
9138  * wiphy_WARN() acts like wiphy_printk(), but with the key difference
9139  * of using a WARN/WARN_ON to get the message out, including the
9140  * file/line information and a backtrace.
9141  */
9142 #define wiphy_WARN(wiphy, format, args...)			\
9143 	WARN(1, "wiphy: %s\n" format, wiphy_name(wiphy), ##args);
9144 
9145 /**
9146  * cfg80211_update_owe_info_event - Notify the peer's OWE info to user space
9147  * @netdev: network device
9148  * @owe_info: peer's owe info
9149  * @gfp: allocation flags
9150  */
9151 void cfg80211_update_owe_info_event(struct net_device *netdev,
9152 				    struct cfg80211_update_owe_info *owe_info,
9153 				    gfp_t gfp);
9154 
9155 /**
9156  * cfg80211_bss_flush - resets all the scan entries
9157  * @wiphy: the wiphy
9158  */
9159 void cfg80211_bss_flush(struct wiphy *wiphy);
9160 
9161 /**
9162  * cfg80211_bss_color_notify - notify about bss color event
9163  * @dev: network device
9164  * @cmd: the actual event we want to notify
9165  * @count: the number of TBTTs until the color change happens
9166  * @color_bitmap: representations of the colors that the local BSS is aware of
9167  */
9168 int cfg80211_bss_color_notify(struct net_device *dev,
9169 			      enum nl80211_commands cmd, u8 count,
9170 			      u64 color_bitmap);
9171 
9172 /**
9173  * cfg80211_obss_color_collision_notify - notify about bss color collision
9174  * @dev: network device
9175  * @color_bitmap: representations of the colors that the local BSS is aware of
9176  */
cfg80211_obss_color_collision_notify(struct net_device * dev,u64 color_bitmap)9177 static inline int cfg80211_obss_color_collision_notify(struct net_device *dev,
9178 						       u64 color_bitmap)
9179 {
9180 	return cfg80211_bss_color_notify(dev, NL80211_CMD_OBSS_COLOR_COLLISION,
9181 					 0, color_bitmap);
9182 }
9183 
9184 /**
9185  * cfg80211_color_change_started_notify - notify color change start
9186  * @dev: the device on which the color is switched
9187  * @count: the number of TBTTs until the color change happens
9188  *
9189  * Inform the userspace about the color change that has started.
9190  */
cfg80211_color_change_started_notify(struct net_device * dev,u8 count)9191 static inline int cfg80211_color_change_started_notify(struct net_device *dev,
9192 						       u8 count)
9193 {
9194 	return cfg80211_bss_color_notify(dev, NL80211_CMD_COLOR_CHANGE_STARTED,
9195 					 count, 0);
9196 }
9197 
9198 /**
9199  * cfg80211_color_change_aborted_notify - notify color change abort
9200  * @dev: the device on which the color is switched
9201  *
9202  * Inform the userspace about the color change that has aborted.
9203  */
cfg80211_color_change_aborted_notify(struct net_device * dev)9204 static inline int cfg80211_color_change_aborted_notify(struct net_device *dev)
9205 {
9206 	return cfg80211_bss_color_notify(dev, NL80211_CMD_COLOR_CHANGE_ABORTED,
9207 					 0, 0);
9208 }
9209 
9210 /**
9211  * cfg80211_color_change_notify - notify color change completion
9212  * @dev: the device on which the color was switched
9213  *
9214  * Inform the userspace about the color change that has completed.
9215  */
cfg80211_color_change_notify(struct net_device * dev)9216 static inline int cfg80211_color_change_notify(struct net_device *dev)
9217 {
9218 	return cfg80211_bss_color_notify(dev,
9219 					 NL80211_CMD_COLOR_CHANGE_COMPLETED,
9220 					 0, 0);
9221 }
9222 
9223 /**
9224  * cfg80211_valid_disable_subchannel_bitmap - validate puncturing bitmap
9225  * @bitmap: bitmap to be validated
9226  * @chandef: channel definition
9227  *
9228  * Validate the puncturing bitmap.
9229  *
9230  * Return: %true if the bitmap is valid. %false otherwise.
9231  */
9232 bool cfg80211_valid_disable_subchannel_bitmap(u16 *bitmap,
9233 					      const struct cfg80211_chan_def *chandef);
9234 
9235 /**
9236  * cfg80211_links_removed - Notify about removed STA MLD setup links.
9237  * @dev: network device.
9238  * @link_mask: BIT mask of removed STA MLD setup link IDs.
9239  *
9240  * Inform cfg80211 and the userspace about removed STA MLD setup links due to
9241  * AP MLD removing the corresponding affiliated APs with Multi-Link
9242  * reconfiguration. Note that it's not valid to remove all links, in this
9243  * case disconnect instead.
9244  * Also note that the wdev mutex must be held.
9245  */
9246 void cfg80211_links_removed(struct net_device *dev, u16 link_mask);
9247 
9248 #endif /* __NET_CFG80211_H */
9249