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