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