Quelle  cfg80211.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-only */
#ifndef __NET_CFG80211_H
#define __NET_CFG80211_H
/*
 * 802.11 device and configuration interface
 *
 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
 * Copyright 2013-2014 Intel Mobile Communications GmbH
 * Copyright 2015-2017 Intel Deutschland GmbH
 * Copyright (C) 2018-2025 Intel Corporation
 */

#include <linux/ethtool.h>
#include <uapi/linux/rfkill.h>
#include <linux/netdevice.h>
#include <linux/debugfs.h>
#include <linux/list.h>
#include <linux/bug.h>
#include <linux/netlink.h>
#include <linux/skbuff.h>
#include <linux/nl80211.h>
#include <linux/if_ether.h>
#include <linux/ieee80211.h>
#include <linux/net.h>
#include <linux/rfkill.h>
#include <net/regulatory.h>

/**
 * DOC: Introduction
 *
 * cfg80211 is the configuration API for 802.11 devices in Linux. It bridges
 * userspace and drivers, and offers some utility functionality associated
 * with 802.11. cfg80211 must, directly or indirectly via mac80211, be used
 * by all modern wireless drivers in Linux, so that they offer a consistent
 * API through nl80211. For backward compatibility, cfg80211 also offers
 * wireless extensions to userspace, but hides them from drivers completely.
 *
 * Additionally, cfg80211 contains code to help enforce regulatory spectrum
 * use restrictions.
 */


/**
 * DOC: Device registration
 *
 * In order for a driver to use cfg80211, it must register the hardware device
 * with cfg80211. This happens through a number of hardware capability structs
 * described below.
 *
 * The fundamental structure for each device is the 'wiphy', of which each
 * instance describes a physical wireless device connected to the system. Each
 * such wiphy can have zero, one, or many virtual interfaces associated with
 * it, which need to be identified as such by pointing the network interface's
 * @ieee80211_ptr pointer to a &struct wireless_dev which further describes
 * the wireless part of the interface. Normally this struct is embedded in the
 * network interface's private data area. Drivers can optionally allow creating
 * or destroying virtual interfaces on the fly, but without at least one or the
 * ability to create some the wireless device isn't useful.
 *
 * Each wiphy structure contains device capability information, and also has
 * a pointer to the various operations the driver offers. The definitions and
 * structures here describe these capabilities in detail.
 */

struct wiphy;

/*
 * wireless hardware capability structures
 */

/**
 * enum ieee80211_channel_flags - channel flags
 *
 * Channel flags set by the regulatory control code.
 *
 * @IEEE80211_CHAN_DISABLED: This channel is disabled.
 * @IEEE80211_CHAN_NO_IR: do not initiate radiation, this includes
 * sending probe requests or beaconing.
 * @IEEE80211_CHAN_PSD: Power spectral density (in dBm) is set for this
 * channel.
 * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel.
 * @IEEE80211_CHAN_NO_HT40PLUS: extension channel above this channel
 * is not permitted.
 * @IEEE80211_CHAN_NO_HT40MINUS: extension channel below this channel
 * is not permitted.
 * @IEEE80211_CHAN_NO_OFDM: OFDM is not allowed on this channel.
 * @IEEE80211_CHAN_NO_80MHZ: If the driver supports 80 MHz on the band,
 * this flag indicates that an 80 MHz channel cannot use this
 * channel as the control or any of the secondary channels.
 * This may be due to the driver or due to regulatory bandwidth
 * restrictions.
 * @IEEE80211_CHAN_NO_160MHZ: If the driver supports 160 MHz on the band,
 * this flag indicates that an 160 MHz channel cannot use this
 * channel as the control or any of the secondary channels.
 * This may be due to the driver or due to regulatory bandwidth
 * restrictions.
 * @IEEE80211_CHAN_INDOOR_ONLY: see %NL80211_FREQUENCY_ATTR_INDOOR_ONLY
 * @IEEE80211_CHAN_IR_CONCURRENT: see %NL80211_FREQUENCY_ATTR_IR_CONCURRENT
 * @IEEE80211_CHAN_NO_20MHZ: 20 MHz bandwidth is not permitted
 * on this channel.
 * @IEEE80211_CHAN_NO_10MHZ: 10 MHz bandwidth is not permitted
 * on this channel.
 * @IEEE80211_CHAN_NO_HE: HE operation is not permitted on this channel.
 * @IEEE80211_CHAN_1MHZ: 1 MHz bandwidth is permitted
 * on this channel.
 * @IEEE80211_CHAN_2MHZ: 2 MHz bandwidth is permitted
 * on this channel.
 * @IEEE80211_CHAN_4MHZ: 4 MHz bandwidth is permitted
 * on this channel.
 * @IEEE80211_CHAN_8MHZ: 8 MHz bandwidth is permitted
 * on this channel.
 * @IEEE80211_CHAN_16MHZ: 16 MHz bandwidth is permitted
 * on this channel.
 * @IEEE80211_CHAN_NO_320MHZ: If the driver supports 320 MHz on the band,
 * this flag indicates that a 320 MHz channel cannot use this
 * channel as the control or any of the secondary channels.
 * This may be due to the driver or due to regulatory bandwidth
 * restrictions.
 * @IEEE80211_CHAN_NO_EHT: EHT operation is not permitted on this channel.
 * @IEEE80211_CHAN_DFS_CONCURRENT: See %NL80211_RRF_DFS_CONCURRENT
 * @IEEE80211_CHAN_NO_6GHZ_VLP_CLIENT: Client connection with VLP AP
 * not permitted using this channel
 * @IEEE80211_CHAN_NO_6GHZ_AFC_CLIENT: Client connection with AFC AP
 * not permitted using this channel
 * @IEEE80211_CHAN_CAN_MONITOR: This channel can be used for monitor
 * mode even in the presence of other (regulatory) restrictions,
 * even if it is otherwise disabled.
 * @IEEE80211_CHAN_ALLOW_6GHZ_VLP_AP: Allow using this channel for AP operation
 * with very low power (VLP), even if otherwise set to NO_IR.
 * @IEEE80211_CHAN_ALLOW_20MHZ_ACTIVITY: Allow activity on a 20 MHz channel,
 * even if otherwise set to NO_IR.
 */
enum ieee80211_channel_flags {
 IEEE80211_CHAN_DISABLED   = BIT(0),
 IEEE80211_CHAN_NO_IR   = BIT(1),
 IEEE80211_CHAN_PSD   = BIT(2),
 IEEE80211_CHAN_RADAR   = BIT(3),
 IEEE80211_CHAN_NO_HT40PLUS  = BIT(4),
 IEEE80211_CHAN_NO_HT40MINUS  = BIT(5),
 IEEE80211_CHAN_NO_OFDM   = BIT(6),
 IEEE80211_CHAN_NO_80MHZ   = BIT(7),
 IEEE80211_CHAN_NO_160MHZ  = BIT(8),
 IEEE80211_CHAN_INDOOR_ONLY  = BIT(9),
 IEEE80211_CHAN_IR_CONCURRENT  = BIT(10),
 IEEE80211_CHAN_NO_20MHZ   = BIT(11),
 IEEE80211_CHAN_NO_10MHZ   = BIT(12),
 IEEE80211_CHAN_NO_HE   = BIT(13),
 IEEE80211_CHAN_1MHZ   = BIT(14),
 IEEE80211_CHAN_2MHZ   = BIT(15),
 IEEE80211_CHAN_4MHZ   = BIT(16),
 IEEE80211_CHAN_8MHZ   = BIT(17),
 IEEE80211_CHAN_16MHZ   = BIT(18),
 IEEE80211_CHAN_NO_320MHZ  = BIT(19),
 IEEE80211_CHAN_NO_EHT   = BIT(20),
 IEEE80211_CHAN_DFS_CONCURRENT  = BIT(21),
 IEEE80211_CHAN_NO_6GHZ_VLP_CLIENT = BIT(22),
 IEEE80211_CHAN_NO_6GHZ_AFC_CLIENT = BIT(23),
 IEEE80211_CHAN_CAN_MONITOR  = BIT(24),
 IEEE80211_CHAN_ALLOW_6GHZ_VLP_AP = BIT(25),
 IEEE80211_CHAN_ALLOW_20MHZ_ACTIVITY     = BIT(26),
};

#define IEEE80211_CHAN_NO_HT40 \
 (IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS)

#define IEEE80211_DFS_MIN_CAC_TIME_MS  60000
#define IEEE80211_DFS_MIN_NOP_TIME_MS  (30 * 60 * 1000)

/**
 * struct ieee80211_channel - channel definition
 *
 * This structure describes a single channel for use
 * with cfg80211.
 *
 * @center_freq: center frequency in MHz
 * @freq_offset: offset from @center_freq, in KHz
 * @hw_value: hardware-specific value for the channel
 * @flags: channel flags from &enum ieee80211_channel_flags.
 * @orig_flags: channel flags at registration time, used by regulatory
 * code to support devices with additional restrictions
 * @band: band this channel belongs to.
 * @max_antenna_gain: maximum antenna gain in dBi
 * @max_power: maximum transmission power (in dBm)
 * @max_reg_power: maximum regulatory transmission power (in dBm)
 * @beacon_found: helper to regulatory code to indicate when a beacon
 * has been found on this channel. Use regulatory_hint_found_beacon()
 * to enable this, this is useful only on 5 GHz band.
 * @orig_mag: internal use
 * @orig_mpwr: internal use
 * @dfs_state: current state of this channel. Only relevant if radar is required
 * on this channel.
 * @dfs_state_entered: timestamp (jiffies) when the dfs state was entered.
 * @dfs_cac_ms: DFS CAC time in milliseconds, this is valid for DFS channels.
 * @psd: power spectral density (in dBm)
 */
struct ieee80211_channel {
 enum nl80211_band band;
 u32 center_freq;
 u16 freq_offset;
 u16 hw_value;
 u32 flags;
 int max_antenna_gain;
 int max_power;
 int max_reg_power;
 bool beacon_found;
 u32 orig_flags;
 int orig_mag, orig_mpwr;
 enum nl80211_dfs_state dfs_state;
 unsigned long dfs_state_entered;
 unsigned int dfs_cac_ms;
 s8 psd;
};

/**
 * enum ieee80211_rate_flags - rate flags
 *
 * Hardware/specification flags for rates. These are structured
 * in a way that allows using the same bitrate structure for
 * different bands/PHY modes.
 *
 * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short
 * preamble on this bitrate; only relevant in 2.4GHz band and
 * with CCK rates.
 * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate
 * when used with 802.11a (on the 5 GHz band); filled by the
 * core code when registering the wiphy.
 * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate
 * when used with 802.11b (on the 2.4 GHz band); filled by the
 * core code when registering the wiphy.
 * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate
 * when used with 802.11g (on the 2.4 GHz band); filled by the
 * core code when registering the wiphy.
 * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode.
 * @IEEE80211_RATE_SUPPORTS_5MHZ: Rate can be used in 5 MHz mode
 * @IEEE80211_RATE_SUPPORTS_10MHZ: Rate can be used in 10 MHz mode
 */
enum ieee80211_rate_flags {
 IEEE80211_RATE_SHORT_PREAMBLE = BIT(0),
 IEEE80211_RATE_MANDATORY_A = BIT(1),
 IEEE80211_RATE_MANDATORY_B = BIT(2),
 IEEE80211_RATE_MANDATORY_G = BIT(3),
 IEEE80211_RATE_ERP_G  = BIT(4),
 IEEE80211_RATE_SUPPORTS_5MHZ = BIT(5),
 IEEE80211_RATE_SUPPORTS_10MHZ = BIT(6),
};

/**
 * enum ieee80211_bss_type - BSS type filter
 *
 * @IEEE80211_BSS_TYPE_ESS: Infrastructure BSS
 * @IEEE80211_BSS_TYPE_PBSS: Personal BSS
 * @IEEE80211_BSS_TYPE_IBSS: Independent BSS
 * @IEEE80211_BSS_TYPE_MBSS: Mesh BSS
 * @IEEE80211_BSS_TYPE_ANY: Wildcard value for matching any BSS type
 */
enum ieee80211_bss_type {
 IEEE80211_BSS_TYPE_ESS,
 IEEE80211_BSS_TYPE_PBSS,
 IEEE80211_BSS_TYPE_IBSS,
 IEEE80211_BSS_TYPE_MBSS,
 IEEE80211_BSS_TYPE_ANY
};

/**
 * enum ieee80211_privacy - BSS privacy filter
 *
 * @IEEE80211_PRIVACY_ON: privacy bit set
 * @IEEE80211_PRIVACY_OFF: privacy bit clear
 * @IEEE80211_PRIVACY_ANY: Wildcard value for matching any privacy setting
 */
enum ieee80211_privacy {
 IEEE80211_PRIVACY_ON,
 IEEE80211_PRIVACY_OFF,
 IEEE80211_PRIVACY_ANY
};

#define IEEE80211_PRIVACY(x) \
 ((x) ? IEEE80211_PRIVACY_ON : IEEE80211_PRIVACY_OFF)

/**
 * struct ieee80211_rate - bitrate definition
 *
 * This structure describes a bitrate that an 802.11 PHY can
 * operate with. The two values @hw_value and @hw_value_short
 * are only for driver use when pointers to this structure are
 * passed around.
 *
 * @flags: rate-specific flags from &enum ieee80211_rate_flags
 * @bitrate: bitrate in units of 100 Kbps
 * @hw_value: driver/hardware value for this rate
 * @hw_value_short: driver/hardware value for this rate when
 * short preamble is used
 */
struct ieee80211_rate {
 u32 flags;
 u16 bitrate;
 u16 hw_value, hw_value_short;
};

/**
 * struct ieee80211_he_obss_pd - AP settings for spatial reuse
 *
 * @enable: is the feature enabled.
 * @sr_ctrl: The SR Control field of SRP element.
 * @non_srg_max_offset: non-SRG maximum tx power offset
 * @min_offset: minimal tx power offset an associated station shall use
 * @max_offset: maximum tx power offset an associated station shall use
 * @bss_color_bitmap: bitmap that indicates the BSS color values used by
 * members of the SRG
 * @partial_bssid_bitmap: bitmap that indicates the partial BSSID values
 * used by members of the SRG
 */
struct ieee80211_he_obss_pd {
 bool enable;
 u8 sr_ctrl;
 u8 non_srg_max_offset;
 u8 min_offset;
 u8 max_offset;
 u8 bss_color_bitmap[8];
 u8 partial_bssid_bitmap[8];
};

/**
 * struct cfg80211_he_bss_color - AP settings for BSS coloring
 *
 * @color: the current color.
 * @enabled: HE BSS color is used
 * @partial: define the AID equation.
 */
struct cfg80211_he_bss_color {
 u8 color;
 bool enabled;
 bool partial;
};

/**
 * struct ieee80211_sta_ht_cap - STA's HT capabilities
 *
 * This structure describes most essential parameters needed
 * to describe 802.11n HT capabilities for an STA.
 *
 * @ht_supported: is HT supported by the STA
 * @cap: HT capabilities map as described in 802.11n spec
 * @ampdu_factor: Maximum A-MPDU length factor
 * @ampdu_density: Minimum A-MPDU spacing
 * @mcs: Supported MCS rates
 */
struct ieee80211_sta_ht_cap {
 u16 cap; /* use IEEE80211_HT_CAP_ */
 bool ht_supported;
 u8 ampdu_factor;
 u8 ampdu_density;
 struct ieee80211_mcs_info mcs;
};

/**
 * struct ieee80211_sta_vht_cap - STA's VHT capabilities
 *
 * This structure describes most essential parameters needed
 * to describe 802.11ac VHT capabilities for an STA.
 *
 * @vht_supported: is VHT supported by the STA
 * @cap: VHT capabilities map as described in 802.11ac spec
 * @vht_mcs: Supported VHT MCS rates
 */
struct ieee80211_sta_vht_cap {
 bool vht_supported;
 u32 cap; /* use IEEE80211_VHT_CAP_ */
 struct ieee80211_vht_mcs_info vht_mcs;
};

#define IEEE80211_HE_PPE_THRES_MAX_LEN  25

/**
 * struct ieee80211_sta_he_cap - STA's HE capabilities
 *
 * This structure describes most essential parameters needed
 * to describe 802.11ax HE capabilities for a STA.
 *
 * @has_he: true iff HE data is valid.
 * @he_cap_elem: Fixed portion of the HE capabilities element.
 * @he_mcs_nss_supp: The supported NSS/MCS combinations.
 * @ppe_thres: Holds the PPE Thresholds data.
 */
struct ieee80211_sta_he_cap {
 bool has_he;
 struct ieee80211_he_cap_elem he_cap_elem;
 struct ieee80211_he_mcs_nss_supp he_mcs_nss_supp;
 u8 ppe_thres[IEEE80211_HE_PPE_THRES_MAX_LEN];
};

/**
 * struct ieee80211_eht_mcs_nss_supp - EHT max supported NSS per MCS
 *
 * See P802.11be_D1.3 Table 9-401k - "Subfields of the Supported EHT-MCS
 * and NSS Set field"
 *
 * @only_20mhz: MCS/NSS support for 20 MHz-only STA.
 * @bw: MCS/NSS support for 80, 160 and 320 MHz
 * @bw._80: MCS/NSS support for BW <= 80 MHz
 * @bw._160: MCS/NSS support for BW = 160 MHz
 * @bw._320: MCS/NSS support for BW = 320 MHz
 */
struct ieee80211_eht_mcs_nss_supp {
 union {
  struct ieee80211_eht_mcs_nss_supp_20mhz_only only_20mhz;
  struct {
   struct ieee80211_eht_mcs_nss_supp_bw _80;
   struct ieee80211_eht_mcs_nss_supp_bw _160;
   struct ieee80211_eht_mcs_nss_supp_bw _320;
  } __packed bw;
 } __packed;
} __packed;

#define IEEE80211_EHT_PPE_THRES_MAX_LEN  32

/**
 * struct ieee80211_sta_eht_cap - STA's EHT capabilities
 *
 * This structure describes most essential parameters needed
 * to describe 802.11be EHT capabilities for a STA.
 *
 * @has_eht: true iff EHT data is valid.
 * @eht_cap_elem: Fixed portion of the eht capabilities element.
 * @eht_mcs_nss_supp: The supported NSS/MCS combinations.
 * @eht_ppe_thres: Holds the PPE Thresholds data.
 */
struct ieee80211_sta_eht_cap {
 bool has_eht;
 struct ieee80211_eht_cap_elem_fixed eht_cap_elem;
 struct ieee80211_eht_mcs_nss_supp eht_mcs_nss_supp;
 u8 eht_ppe_thres[IEEE80211_EHT_PPE_THRES_MAX_LEN];
};

/* sparse defines __CHECKER__; see Documentation/dev-tools/sparse.rst */
#ifdef __CHECKER__
/*
 * This is used to mark the sband->iftype_data pointer which is supposed
 * to be an array with special access semantics (per iftype), but a lot
 * of code got it wrong in the past, so with this marking sparse will be
 * noisy when the pointer is used directly.
 */
# define __iftd  __attribute__((noderef, address_space(__iftype_data)))
#else
# define __iftd
#endif /* __CHECKER__ */

/**
 * struct ieee80211_sband_iftype_data - sband data per interface type
 *
 * This structure encapsulates sband data that is relevant for the
 * interface types defined in @types_mask.  Each type in the
 * @types_mask must be unique across all instances of iftype_data.
 *
 * @types_mask: interface types mask
 * @he_cap: holds the HE capabilities
 * @he_6ghz_capa: HE 6 GHz capabilities, must be filled in for a
 * 6 GHz band channel (and 0 may be valid value).
 * @eht_cap: STA's EHT capabilities
 * @vendor_elems: vendor element(s) to advertise
 * @vendor_elems.data: vendor element(s) data
 * @vendor_elems.len: vendor element(s) length
 */
struct ieee80211_sband_iftype_data {
 u16 types_mask;
 struct ieee80211_sta_he_cap he_cap;
 struct ieee80211_he_6ghz_capa he_6ghz_capa;
 struct ieee80211_sta_eht_cap eht_cap;
 struct {
  const u8 *data;
  unsigned int len;
 } vendor_elems;
};

/**
 * enum ieee80211_edmg_bw_config - allowed channel bandwidth configurations
 *
 * @IEEE80211_EDMG_BW_CONFIG_4: 2.16GHz
 * @IEEE80211_EDMG_BW_CONFIG_5: 2.16GHz and 4.32GHz
 * @IEEE80211_EDMG_BW_CONFIG_6: 2.16GHz, 4.32GHz and 6.48GHz
 * @IEEE80211_EDMG_BW_CONFIG_7: 2.16GHz, 4.32GHz, 6.48GHz and 8.64GHz
 * @IEEE80211_EDMG_BW_CONFIG_8: 2.16GHz and 2.16GHz + 2.16GHz
 * @IEEE80211_EDMG_BW_CONFIG_9: 2.16GHz, 4.32GHz and 2.16GHz + 2.16GHz
 * @IEEE80211_EDMG_BW_CONFIG_10: 2.16GHz, 4.32GHz, 6.48GHz and 2.16GHz+2.16GHz
 * @IEEE80211_EDMG_BW_CONFIG_11: 2.16GHz, 4.32GHz, 6.48GHz, 8.64GHz and
 * 2.16GHz+2.16GHz
 * @IEEE80211_EDMG_BW_CONFIG_12: 2.16GHz, 2.16GHz + 2.16GHz and
 * 4.32GHz + 4.32GHz
 * @IEEE80211_EDMG_BW_CONFIG_13: 2.16GHz, 4.32GHz, 2.16GHz + 2.16GHz and
 * 4.32GHz + 4.32GHz
 * @IEEE80211_EDMG_BW_CONFIG_14: 2.16GHz, 4.32GHz, 6.48GHz, 2.16GHz + 2.16GHz
 * and 4.32GHz + 4.32GHz
 * @IEEE80211_EDMG_BW_CONFIG_15: 2.16GHz, 4.32GHz, 6.48GHz, 8.64GHz,
 * 2.16GHz + 2.16GHz and 4.32GHz + 4.32GHz
 */
enum ieee80211_edmg_bw_config {
 IEEE80211_EDMG_BW_CONFIG_4 = 4,
 IEEE80211_EDMG_BW_CONFIG_5 = 5,
 IEEE80211_EDMG_BW_CONFIG_6 = 6,
 IEEE80211_EDMG_BW_CONFIG_7 = 7,
 IEEE80211_EDMG_BW_CONFIG_8 = 8,
 IEEE80211_EDMG_BW_CONFIG_9 = 9,
 IEEE80211_EDMG_BW_CONFIG_10 = 10,
 IEEE80211_EDMG_BW_CONFIG_11 = 11,
 IEEE80211_EDMG_BW_CONFIG_12 = 12,
 IEEE80211_EDMG_BW_CONFIG_13 = 13,
 IEEE80211_EDMG_BW_CONFIG_14 = 14,
 IEEE80211_EDMG_BW_CONFIG_15 = 15,
};

/**
 * struct ieee80211_edmg - EDMG configuration
 *
 * This structure describes most essential parameters needed
 * to describe 802.11ay EDMG configuration
 *
 * @channels: bitmap that indicates the 2.16 GHz channel(s)
 * that are allowed to be used for transmissions.
 * Bit 0 indicates channel 1, bit 1 indicates channel 2, etc.
 * Set to 0 indicate EDMG not supported.
 * @bw_config: Channel BW Configuration subfield encodes
 * the allowed channel bandwidth configurations
 */
struct ieee80211_edmg {
 u8 channels;
 enum ieee80211_edmg_bw_config bw_config;
};

/**
 * struct ieee80211_sta_s1g_cap - STA's S1G capabilities
 *
 * This structure describes most essential parameters needed
 * to describe 802.11ah S1G capabilities for a STA.
 *
 * @s1g: is STA an S1G STA
 * @cap: S1G capabilities information
 * @nss_mcs: Supported NSS MCS set
 */
struct ieee80211_sta_s1g_cap {
 bool s1g;
 u8 cap[10]; /* use S1G_CAPAB_ */
 u8 nss_mcs[5];
};

/**
 * struct ieee80211_supported_band - frequency band definition
 *
 * This structure describes a frequency band a wiphy
 * is able to operate in.
 *
 * @channels: Array of channels the hardware can operate with
 * in this band.
 * @band: the band this structure represents
 * @n_channels: Number of channels in @channels
 * @bitrates: Array of bitrates the hardware can operate with
 * in this band. Must be sorted to give a valid "supported
 * rates" IE, i.e. CCK rates first, then OFDM.
 * @n_bitrates: Number of bitrates in @bitrates
 * @ht_cap: HT capabilities in this band
 * @vht_cap: VHT capabilities in this band
 * @s1g_cap: S1G capabilities in this band
 * @edmg_cap: EDMG capabilities in this band
 * @s1g_cap: S1G capabilities in this band (S1G band only, of course)
 * @n_iftype_data: number of iftype data entries
 * @iftype_data: interface type data entries.  Note that the bits in
 * @types_mask inside this structure cannot overlap (i.e. only
 * one occurrence of each type is allowed across all instances of
 * iftype_data).
 */
struct ieee80211_supported_band {
 struct ieee80211_channel *channels;
 struct ieee80211_rate *bitrates;
 enum nl80211_band band;
 int n_channels;
 int n_bitrates;
 struct ieee80211_sta_ht_cap ht_cap;
 struct ieee80211_sta_vht_cap vht_cap;
 struct ieee80211_sta_s1g_cap s1g_cap;
 struct ieee80211_edmg edmg_cap;
 u16 n_iftype_data;
 const struct ieee80211_sband_iftype_data __iftd *iftype_data;
};

/**
 * _ieee80211_set_sband_iftype_data - set sband iftype data array
 * @sband: the sband to initialize
 * @iftd: the iftype data array pointer
 * @n_iftd: the length of the iftype data array
 *
 * Set the sband iftype data array; use this where the length cannot
 * be derived from the ARRAY_SIZE() of the argument, but prefer
 * ieee80211_set_sband_iftype_data() where it can be used.
 */
static inline void
_ieee80211_set_sband_iftype_data(struct ieee80211_supported_band *sband,
     const struct ieee80211_sband_iftype_data *iftd,
     u16 n_iftd)
{
 sband->iftype_data = (const void __iftd __force *)iftd;
 sband->n_iftype_data = n_iftd;
}

/**
 * ieee80211_set_sband_iftype_data - set sband iftype data array
 * @sband: the sband to initialize
 * @iftd: the iftype data array
 */
#define ieee80211_set_sband_iftype_data(sband, iftd) \
 _ieee80211_set_sband_iftype_data(sband, iftd, ARRAY_SIZE(iftd))

/**
 * for_each_sband_iftype_data - iterate sband iftype data entries
 * @sband: the sband whose iftype_data array to iterate
 * @i: iterator counter
 * @iftd: iftype data pointer to set
 */
#define for_each_sband_iftype_data(sband, i, iftd)    \
 for (i = 0, iftd = (const void __force *)&(sband)->iftype_data[i]; \
      i < (sband)->n_iftype_data;     \
      i++, iftd = (const void __force *)&(sband)->iftype_data[i])

/**
 * ieee80211_get_sband_iftype_data - return sband data for a given iftype
 * @sband: the sband to search for the STA on
 * @iftype: enum nl80211_iftype
 *
 * Return: pointer to struct ieee80211_sband_iftype_data, or NULL is none found
 */
static inline const struct ieee80211_sband_iftype_data *
ieee80211_get_sband_iftype_data(const struct ieee80211_supported_band *sband,
    u8 iftype)
{
 const struct ieee80211_sband_iftype_data *data;
 int i;

 if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
  return NULL;

 if (iftype == NL80211_IFTYPE_AP_VLAN)
  iftype = NL80211_IFTYPE_AP;

 for_each_sband_iftype_data(sband, i, data) {
  if (data->types_mask & BIT(iftype))
   return data;
 }

 return NULL;
}

/**
 * ieee80211_get_he_iftype_cap - return HE capabilities for an sband's iftype
 * @sband: the sband to search for the iftype on
 * @iftype: enum nl80211_iftype
 *
 * Return: pointer to the struct ieee80211_sta_he_cap, or NULL is none found
 */
static inline const struct ieee80211_sta_he_cap *
ieee80211_get_he_iftype_cap(const struct ieee80211_supported_band *sband,
       u8 iftype)
{
 const struct ieee80211_sband_iftype_data *data =
  ieee80211_get_sband_iftype_data(sband, iftype);

 if (data && data->he_cap.has_he)
  return &data->he_cap;

 return NULL;
}

/**
 * ieee80211_get_he_6ghz_capa - return HE 6 GHz capabilities
 * @sband: the sband to search for the STA on
 * @iftype: the iftype to search for
 *
 * Return: the 6GHz capabilities
 */
static inline __le16
ieee80211_get_he_6ghz_capa(const struct ieee80211_supported_band *sband,
      enum nl80211_iftype iftype)
{
 const struct ieee80211_sband_iftype_data *data =
  ieee80211_get_sband_iftype_data(sband, iftype);

 if (WARN_ON(!data || !data->he_cap.has_he))
  return 0;

 return data->he_6ghz_capa.capa;
}

/**
 * ieee80211_get_eht_iftype_cap - return ETH capabilities for an sband's iftype
 * @sband: the sband to search for the iftype on
 * @iftype: enum nl80211_iftype
 *
 * Return: pointer to the struct ieee80211_sta_eht_cap, or NULL is none found
 */
static inline const struct ieee80211_sta_eht_cap *
ieee80211_get_eht_iftype_cap(const struct ieee80211_supported_band *sband,
        enum nl80211_iftype iftype)
{
 const struct ieee80211_sband_iftype_data *data =
  ieee80211_get_sband_iftype_data(sband, iftype);

 if (data && data->eht_cap.has_eht)
  return &data->eht_cap;

 return NULL;
}

/**
 * wiphy_read_of_freq_limits - read frequency limits from device tree
 *
 * @wiphy: the wireless device to get extra limits for
 *
 * Some devices may have extra limitations specified in DT. This may be useful
 * for chipsets that normally support more bands but are limited due to board
 * design (e.g. by antennas or external power amplifier).
 *
 * This function reads info from DT and uses it to *modify* channels (disable
 * unavailable ones). It's usually a *bad* idea to use it in drivers with
 * shared channel data as DT limitations are device specific. You should make
 * sure to call it only if channels in wiphy are copied and can be modified
 * without affecting other devices.
 *
 * As this function access device node it has to be called after set_wiphy_dev.
 * It also modifies channels so they have to be set first.
 * If using this helper, call it before wiphy_register().
 */
#ifdef CONFIG_OF
void wiphy_read_of_freq_limits(struct wiphy *wiphy);
#else /* CONFIG_OF */
static inline void wiphy_read_of_freq_limits(struct wiphy *wiphy)
{
}
#endif /* !CONFIG_OF */


/*
 * Wireless hardware/device configuration structures and methods
 */

/**
 * DOC: Actions and configuration
 *
 * Each wireless device and each virtual interface offer a set of configuration
 * operations and other actions that are invoked by userspace. Each of these
 * actions is described in the operations structure, and the parameters these
 * operations use are described separately.
 *
 * Additionally, some operations are asynchronous and expect to get status
 * information via some functions that drivers need to call.
 *
 * Scanning and BSS list handling with its associated functionality is described
 * in a separate chapter.
 */

#define VHT_MUMIMO_GROUPS_DATA_LEN (WLAN_MEMBERSHIP_LEN +\
        WLAN_USER_POSITION_LEN)

/**
 * struct vif_params - describes virtual interface parameters
 * @flags: monitor interface flags, unchanged if 0, otherwise
 * %MONITOR_FLAG_CHANGED will be set
 * @use_4addr: use 4-address frames
 * @macaddr: address to use for this virtual interface.
 * If this parameter is set to zero address the driver may
 * determine the address as needed.
 * This feature is only fully supported by drivers that enable the
 * %NL80211_FEATURE_MAC_ON_CREATE flag.  Others may support creating
 ** only p2p devices with specified MAC.
 * @vht_mumimo_groups: MU-MIMO groupID, used for monitoring MU-MIMO packets
 * belonging to that MU-MIMO groupID; %NULL if not changed
 * @vht_mumimo_follow_addr: MU-MIMO follow address, used for monitoring
 * MU-MIMO packets going to the specified station; %NULL if not changed
 */
struct vif_params {
 u32 flags;
 int use_4addr;
 u8 macaddr[ETH_ALEN];
 const u8 *vht_mumimo_groups;
 const u8 *vht_mumimo_follow_addr;
};

/**
 * struct key_params - key information
 *
 * Information about a key
 *
 * @key: key material
 * @key_len: length of key material
 * @cipher: cipher suite selector
 * @seq: sequence counter (IV/PN) for TKIP and CCMP keys, only used
 * with the get_key() callback, must be in little endian,
 * length given by @seq_len.
 * @seq_len: length of @seq.
 * @vlan_id: vlan_id for VLAN group key (if nonzero)
 * @mode: key install mode (RX_TX, NO_TX or SET_TX)
 */
struct key_params {
 const u8 *key;
 const u8 *seq;
 int key_len;
 int seq_len;
 u16 vlan_id;
 u32 cipher;
 enum nl80211_key_mode mode;
};

/**
 * struct cfg80211_chan_def - channel definition
 * @chan: the (control) channel
 * @width: channel width
 * @center_freq1: center frequency of first segment
 * @center_freq2: center frequency of second segment
 * (only with 80+80 MHz)
 * @edmg: define the EDMG channels configuration.
 * If edmg is requested (i.e. the .channels member is non-zero),
 * chan will define the primary channel and all other
 * parameters are ignored.
 * @freq1_offset: offset from @center_freq1, in KHz
 * @punctured: mask of the punctured 20 MHz subchannels, with
 * bits turned on being disabled (punctured); numbered
 * from lower to higher frequency (like in the spec)
 */
struct cfg80211_chan_def {
 struct ieee80211_channel *chan;
 enum nl80211_chan_width width;
 u32 center_freq1;
 u32 center_freq2;
 struct ieee80211_edmg edmg;
 u16 freq1_offset;
 u16 punctured;
};

/*
 * cfg80211_bitrate_mask - masks for bitrate control
 */
struct cfg80211_bitrate_mask {
 struct {
  u32 legacy;
  u8 ht_mcs[IEEE80211_HT_MCS_MASK_LEN];
  u16 vht_mcs[NL80211_VHT_NSS_MAX];
  u16 he_mcs[NL80211_HE_NSS_MAX];
  enum nl80211_txrate_gi gi;
  enum nl80211_he_gi he_gi;
  enum nl80211_he_ltf he_ltf;
 } control[NUM_NL80211_BANDS];
};


/**
 * struct cfg80211_tid_cfg - TID specific configuration
 * @config_override: Flag to notify driver to reset TID configuration
 * of the peer.
 * @tids: bitmap of TIDs to modify
 * @mask: bitmap of attributes indicating which parameter changed,
 * similar to &nl80211_tid_config_supp.
 * @noack: noack configuration value for the TID
 * @retry_long: retry count value
 * @retry_short: retry count value
 * @ampdu: Enable/Disable MPDU aggregation
 * @rtscts: Enable/Disable RTS/CTS
 * @amsdu: Enable/Disable MSDU aggregation
 * @txrate_type: Tx bitrate mask type
 * @txrate_mask: Tx bitrate to be applied for the TID
 */
struct cfg80211_tid_cfg {
 bool config_override;
 u8 tids;
 u64 mask;
 enum nl80211_tid_config noack;
 u8 retry_long, retry_short;
 enum nl80211_tid_config ampdu;
 enum nl80211_tid_config rtscts;
 enum nl80211_tid_config amsdu;
 enum nl80211_tx_rate_setting txrate_type;
 struct cfg80211_bitrate_mask txrate_mask;
};

/**
 * struct cfg80211_tid_config - TID configuration
 * @peer: Station's MAC address
 * @n_tid_conf: Number of TID specific configurations to be applied
 * @tid_conf: Configuration change info
 */
struct cfg80211_tid_config {
 const u8 *peer;
 u32 n_tid_conf;
 struct cfg80211_tid_cfg tid_conf[] __counted_by(n_tid_conf);
};

/**
 * struct cfg80211_fils_aad - FILS AAD data
 * @macaddr: STA MAC address
 * @kek: FILS KEK
 * @kek_len: FILS KEK length
 * @snonce: STA Nonce
 * @anonce: AP Nonce
 */
struct cfg80211_fils_aad {
 const u8 *macaddr;
 const u8 *kek;
 u8 kek_len;
 const u8 *snonce;
 const u8 *anonce;
};

/**
 * struct cfg80211_set_hw_timestamp - enable/disable HW timestamping
 * @macaddr: peer MAC address. NULL to enable/disable HW timestamping for all
 * addresses.
 * @enable: if set, enable HW timestamping for the specified MAC address.
 * Otherwise disable HW timestamping for the specified MAC address.
 */
struct cfg80211_set_hw_timestamp {
 const u8 *macaddr;
 bool enable;
};

/**
 * cfg80211_get_chandef_type - return old channel type from chandef
 * @chandef: the channel definition
 *
 * Return: The old channel type (NOHT, HT20, HT40+/-) from a given
 * chandef, which must have a bandwidth allowing this conversion.
 */
static inline enum nl80211_channel_type
cfg80211_get_chandef_type(const struct cfg80211_chan_def *chandef)
{
 switch (chandef->width) {
 case NL80211_CHAN_WIDTH_20_NOHT:
  return NL80211_CHAN_NO_HT;
 case NL80211_CHAN_WIDTH_20:
  return NL80211_CHAN_HT20;
 case NL80211_CHAN_WIDTH_40:
  if (chandef->center_freq1 > chandef->chan->center_freq)
   return NL80211_CHAN_HT40PLUS;
  return NL80211_CHAN_HT40MINUS;
 default:
  WARN_ON(1);
  return NL80211_CHAN_NO_HT;
 }
}

/**
 * cfg80211_chandef_create - create channel definition using channel type
 * @chandef: the channel definition struct to fill
 * @channel: the control channel
 * @chantype: the channel type
 *
 * Given a channel type, create a channel definition.
 */
void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
        struct ieee80211_channel *channel,
        enum nl80211_channel_type chantype);

/**
 * cfg80211_chandef_identical - check if two channel definitions are identical
 * @chandef1: first channel definition
 * @chandef2: second channel definition
 *
 * Return: %true if the channels defined by the channel definitions are
 * identical, %false otherwise.
 */
static inline bool
cfg80211_chandef_identical(const struct cfg80211_chan_def *chandef1,
      const struct cfg80211_chan_def *chandef2)
{
 return (chandef1->chan == chandef2->chan &&
  chandef1->width == chandef2->width &&
  chandef1->center_freq1 == chandef2->center_freq1 &&
  chandef1->freq1_offset == chandef2->freq1_offset &&
  chandef1->center_freq2 == chandef2->center_freq2 &&
  chandef1->punctured == chandef2->punctured);
}

/**
 * cfg80211_chandef_is_edmg - check if chandef represents an EDMG channel
 *
 * @chandef: the channel definition
 *
 * Return: %true if EDMG defined, %false otherwise.
 */
static inline bool
cfg80211_chandef_is_edmg(const struct cfg80211_chan_def *chandef)
{
 return chandef->edmg.channels || chandef->edmg.bw_config;
}

/**
 * cfg80211_chandef_compatible - check if two channel definitions are compatible
 * @chandef1: first channel definition
 * @chandef2: second channel definition
 *
 * Return: %NULL if the given channel definitions are incompatible,
 * chandef1 or chandef2 otherwise.
 */
const struct cfg80211_chan_def *
cfg80211_chandef_compatible(const struct cfg80211_chan_def *chandef1,
       const struct cfg80211_chan_def *chandef2);

/**
 * nl80211_chan_width_to_mhz - get the channel width in MHz
 * @chan_width: the channel width from &enum nl80211_chan_width
 *
 * Return: channel width in MHz if the chan_width from &enum nl80211_chan_width
 * is valid. -1 otherwise.
 */
int nl80211_chan_width_to_mhz(enum nl80211_chan_width chan_width);

/**
 * cfg80211_chandef_get_width - return chandef width in MHz
 * @c: chandef to return bandwidth for
 * Return: channel width in MHz for the given chandef; note that it returns
 * 80 for 80+80 configurations
 */
static inline int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
{
 return nl80211_chan_width_to_mhz(c->width);
}

/**
 * cfg80211_chandef_valid - check if a channel definition is valid
 * @chandef: the channel definition to check
 * Return: %true if the channel definition is valid. %false otherwise.
 */
bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef);

/**
 * cfg80211_chandef_usable - check if secondary channels can be used
 * @wiphy: the wiphy to validate against
 * @chandef: the channel definition to check
 * @prohibited_flags: the regulatory channel flags that must not be set
 * Return: %true if secondary channels are usable. %false otherwise.
 */
bool cfg80211_chandef_usable(struct wiphy *wiphy,
        const struct cfg80211_chan_def *chandef,
        u32 prohibited_flags);

/**
 * cfg80211_chandef_dfs_required - checks if radar detection is required
 * @wiphy: the wiphy to validate against
 * @chandef: the channel definition to check
 * @iftype: the interface type as specified in &enum nl80211_iftype
 * Returns:
 * 1 if radar detection is required, 0 if it is not, < 0 on error
 */
int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
      const struct cfg80211_chan_def *chandef,
      enum nl80211_iftype iftype);

/**
 * cfg80211_chandef_dfs_usable - checks if chandef is DFS usable and we
 *  can/need start CAC on such channel
 * @wiphy: the wiphy to validate against
 * @chandef: the channel definition to check
 *
 * Return: true if all channels available and at least
 *    one channel requires CAC (NL80211_DFS_USABLE)
 */
bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
     const struct cfg80211_chan_def *chandef);

/**
 * cfg80211_chandef_dfs_cac_time - get the DFS CAC time (in ms) for given
 *    channel definition
 * @wiphy: the wiphy to validate against
 * @chandef: the channel definition to check
 *
 * Returns: DFS CAC time (in ms) which applies for this channel definition
 */
unsigned int
cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
         const struct cfg80211_chan_def *chandef);

/**
 * cfg80211_chandef_primary - calculate primary 40/80/160 MHz freq
 * @chandef: chandef to calculate for
 * @primary_chan_width: primary channel width to calculate center for
 * @punctured: punctured sub-channel bitmap, will be recalculated
 * according to the new bandwidth, can be %NULL
 *
 * Returns: the primary 40/80/160 MHz channel center frequency, or -1
 * for errors, updating the punctured bitmap
 */
int cfg80211_chandef_primary(const struct cfg80211_chan_def *chandef,
        enum nl80211_chan_width primary_chan_width,
        u16 *punctured);

/**
 * nl80211_send_chandef - sends the channel definition.
 * @msg: the msg to send channel definition
 * @chandef: the channel definition to check
 *
 * Returns: 0 if sent the channel definition to msg, < 0 on error
 **/
int nl80211_send_chandef(struct sk_buff *msg, const struct cfg80211_chan_def *chandef);

/**
 * ieee80211_chandef_max_power - maximum transmission power for the chandef
 *
 * In some regulations, the transmit power may depend on the configured channel
 * bandwidth which may be defined as dBm/MHz. This function returns the actual
 * max_power for non-standard (20 MHz) channels.
 *
 * @chandef: channel definition for the channel
 *
 * Returns: maximum allowed transmission power in dBm for the chandef
 */
static inline int
ieee80211_chandef_max_power(struct cfg80211_chan_def *chandef)
{
 switch (chandef->width) {
 case NL80211_CHAN_WIDTH_5:
  return min(chandef->chan->max_reg_power - 6,
      chandef->chan->max_power);
 case NL80211_CHAN_WIDTH_10:
  return min(chandef->chan->max_reg_power - 3,
      chandef->chan->max_power);
 default:
  break;
 }
 return chandef->chan->max_power;
}

/**
 * cfg80211_any_usable_channels - check for usable channels
 * @wiphy: the wiphy to check for
 * @band_mask: which bands to check on
 * @prohibited_flags: which channels to not consider usable,
 * %IEEE80211_CHAN_DISABLED is always taken into account
 *
 * Return: %true if usable channels found, %false otherwise
 */
bool cfg80211_any_usable_channels(struct wiphy *wiphy,
      unsigned long band_mask,
      u32 prohibited_flags);

/**
 * enum survey_info_flags - survey information flags
 *
 * @SURVEY_INFO_NOISE_DBM: noise (in dBm) was filled in
 * @SURVEY_INFO_IN_USE: channel is currently being used
 * @SURVEY_INFO_TIME: active time (in ms) was filled in
 * @SURVEY_INFO_TIME_BUSY: busy time was filled in
 * @SURVEY_INFO_TIME_EXT_BUSY: extension channel busy time was filled in
 * @SURVEY_INFO_TIME_RX: receive time was filled in
 * @SURVEY_INFO_TIME_TX: transmit time was filled in
 * @SURVEY_INFO_TIME_SCAN: scan time was filled in
 * @SURVEY_INFO_TIME_BSS_RX: local BSS receive time was filled in
 *
 * Used by the driver to indicate which info in &struct survey_info
 * it has filled in during the get_survey().
 */
enum survey_info_flags {
 SURVEY_INFO_NOISE_DBM  = BIT(0),
 SURVEY_INFO_IN_USE  = BIT(1),
 SURVEY_INFO_TIME  = BIT(2),
 SURVEY_INFO_TIME_BUSY  = BIT(3),
 SURVEY_INFO_TIME_EXT_BUSY = BIT(4),
 SURVEY_INFO_TIME_RX  = BIT(5),
 SURVEY_INFO_TIME_TX  = BIT(6),
 SURVEY_INFO_TIME_SCAN  = BIT(7),
 SURVEY_INFO_TIME_BSS_RX  = BIT(8),
};

/**
 * struct survey_info - channel survey response
 *
 * @channel: the channel this survey record reports, may be %NULL for a single
 * record to report global statistics
 * @filled: bitflag of flags from &enum survey_info_flags
 * @noise: channel noise in dBm. This and all following fields are
 * optional
 * @time: amount of time in ms the radio was turn on (on the channel)
 * @time_busy: amount of time the primary channel was sensed busy
 * @time_ext_busy: amount of time the extension channel was sensed busy
 * @time_rx: amount of time the radio spent receiving data
 * @time_tx: amount of time the radio spent transmitting data
 * @time_scan: amount of time the radio spent for scanning
 * @time_bss_rx: amount of time the radio spent receiving data on a local BSS
 *
 * Used by dump_survey() to report back per-channel survey information.
 *
 * This structure can later be expanded with things like
 * channel duty cycle etc.
 */
struct survey_info {
 struct ieee80211_channel *channel;
 u64 time;
 u64 time_busy;
 u64 time_ext_busy;
 u64 time_rx;
 u64 time_tx;
 u64 time_scan;
 u64 time_bss_rx;
 u32 filled;
 s8 noise;
};

#define CFG80211_MAX_NUM_AKM_SUITES 10

/**
 * struct cfg80211_crypto_settings - Crypto settings
 * @wpa_versions: indicates which, if any, WPA versions are enabled
 * (from enum nl80211_wpa_versions)
 * @cipher_group: group key cipher suite (or 0 if unset)
 * @n_ciphers_pairwise: number of AP supported unicast ciphers
 * @ciphers_pairwise: unicast key cipher suites
 * @n_akm_suites: number of AKM suites
 * @akm_suites: AKM suites
 * @control_port: Whether user space controls IEEE 802.1X port, i.e.,
 * sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is
 * required to assume that the port is unauthorized until authorized by
 * user space. Otherwise, port is marked authorized by default.
 * @control_port_ethertype: the control port protocol that should be
 * allowed through even on unauthorized ports
 * @control_port_no_encrypt: TRUE to prevent encryption of control port
 * protocol frames.
 * @control_port_over_nl80211: TRUE if userspace expects to exchange control
 * port frames over NL80211 instead of the network interface.
 * @control_port_no_preauth: disables pre-auth rx over the nl80211 control
 * port for mac80211
 * @psk: PSK (for devices supporting 4-way-handshake offload)
 * @sae_pwd: password for SAE authentication (for devices supporting SAE
 * offload)
 * @sae_pwd_len: length of SAE password (for devices supporting SAE offload)
 * @sae_pwe: The mechanisms allowed for SAE PWE derivation:
 *
 * NL80211_SAE_PWE_UNSPECIFIED
 *   Not-specified, used to indicate userspace did not specify any
 *   preference. The driver should follow its internal policy in
 *   such a scenario.
 *
 * NL80211_SAE_PWE_HUNT_AND_PECK
 *   Allow hunting-and-pecking loop only
 *
 * NL80211_SAE_PWE_HASH_TO_ELEMENT
 *   Allow hash-to-element only
 *
 * NL80211_SAE_PWE_BOTH
 *   Allow either hunting-and-pecking loop or hash-to-element
 */
struct cfg80211_crypto_settings {
 u32 wpa_versions;
 u32 cipher_group;
 int n_ciphers_pairwise;
 u32 ciphers_pairwise[NL80211_MAX_NR_CIPHER_SUITES];
 int n_akm_suites;
 u32 akm_suites[CFG80211_MAX_NUM_AKM_SUITES];
 bool control_port;
 __be16 control_port_ethertype;
 bool control_port_no_encrypt;
 bool control_port_over_nl80211;
 bool control_port_no_preauth;
 const u8 *psk;
 const u8 *sae_pwd;
 u8 sae_pwd_len;
 enum nl80211_sae_pwe_mechanism sae_pwe;
};

/**
 * struct cfg80211_mbssid_config - AP settings for multi bssid
 *
 * @tx_wdev: pointer to the transmitted interface in the MBSSID set
 * @tx_link_id: link ID of the transmitted profile in an MLD.
 * @index: index of this AP in the multi bssid group.
 * @ema: set to true if the beacons should be sent out in EMA mode.
 */
struct cfg80211_mbssid_config {
 struct wireless_dev *tx_wdev;
 u8 tx_link_id;
 u8 index;
 bool ema;
};

/**
 * struct cfg80211_mbssid_elems - Multiple BSSID elements
 *
 * @cnt: Number of elements in array %elems.
 *
 * @elem: Array of multiple BSSID element(s) to be added into Beacon frames.
 * @elem.data: Data for multiple BSSID elements.
 * @elem.len: Length of data.
 */
struct cfg80211_mbssid_elems {
 u8 cnt;
 struct {
  const u8 *data;
  size_t len;
 } elem[] __counted_by(cnt);
};

/**
 * struct cfg80211_rnr_elems - Reduced neighbor report (RNR) elements
 *
 * @cnt: Number of elements in array %elems.
 *
 * @elem: Array of RNR element(s) to be added into Beacon frames.
 * @elem.data: Data for RNR elements.
 * @elem.len: Length of data.
 */
struct cfg80211_rnr_elems {
 u8 cnt;
 struct {
  const u8 *data;
  size_t len;
 } elem[] __counted_by(cnt);
};

/**
 * struct cfg80211_beacon_data - beacon data
 * @link_id: the link ID for the AP MLD link sending this beacon
 * @head: head portion of beacon (before TIM IE)
 * or %NULL if not changed
 * @tail: tail portion of beacon (after TIM IE)
 * or %NULL if not changed
 * @head_len: length of @head
 * @tail_len: length of @tail
 * @beacon_ies: extra information element(s) to add into Beacon frames or %NULL
 * @beacon_ies_len: length of beacon_ies in octets
 * @proberesp_ies: extra information element(s) to add into Probe Response
 * frames or %NULL
 * @proberesp_ies_len: length of proberesp_ies in octets
 * @assocresp_ies: extra information element(s) to add into (Re)Association
 * Response frames or %NULL
 * @assocresp_ies_len: length of assocresp_ies in octets
 * @probe_resp_len: length of probe response template (@probe_resp)
 * @probe_resp: probe response template (AP mode only)
 * @mbssid_ies: multiple BSSID elements
 * @rnr_ies: reduced neighbor report elements
 * @ftm_responder: enable FTM responder functionality; -1 for no change
 * (which also implies no change in LCI/civic location data)
 * @lci: Measurement Report element content, starting with Measurement Token
 * (measurement type 8)
 * @civicloc: Measurement Report element content, starting with Measurement
 * Token (measurement type 11)
 * @lci_len: LCI data length
 * @civicloc_len: Civic location data length
 * @he_bss_color: BSS Color settings
 * @he_bss_color_valid: indicates whether bss color
 * attribute is present in beacon data or not.
 */
struct cfg80211_beacon_data {
 unsigned int link_id;

 const u8 *head, *tail;
 const u8 *beacon_ies;
 const u8 *proberesp_ies;
 const u8 *assocresp_ies;
 const u8 *probe_resp;
 const u8 *lci;
 const u8 *civicloc;
 struct cfg80211_mbssid_elems *mbssid_ies;
 struct cfg80211_rnr_elems *rnr_ies;
 s8 ftm_responder;

 size_t head_len, tail_len;
 size_t beacon_ies_len;
 size_t proberesp_ies_len;
 size_t assocresp_ies_len;
 size_t probe_resp_len;
 size_t lci_len;
 size_t civicloc_len;
 struct cfg80211_he_bss_color he_bss_color;
 bool he_bss_color_valid;
};

struct mac_address {
 u8 addr[ETH_ALEN];
};

/**
 * struct cfg80211_acl_data - Access control list data
 *
 * @acl_policy: ACL policy to be applied on the station's
 * entry specified by mac_addr
 * @n_acl_entries: Number of MAC address entries passed
 * @mac_addrs: List of MAC addresses of stations to be used for ACL
 */
struct cfg80211_acl_data {
 enum nl80211_acl_policy acl_policy;
 int n_acl_entries;

 /* Keep it last */
 struct mac_address mac_addrs[] __counted_by(n_acl_entries);
};

/**
 * struct cfg80211_fils_discovery - FILS discovery parameters from
 * IEEE Std 802.11ai-2016, Annex C.3 MIB detail.
 *
 * @update: Set to true if the feature configuration should be updated.
 * @min_interval: Minimum packet interval in TUs (0 - 10000)
 * @max_interval: Maximum packet interval in TUs (0 - 10000)
 * @tmpl_len: Template length
 * @tmpl: Template data for FILS discovery frame including the action
 * frame headers.
 */
struct cfg80211_fils_discovery {
 bool update;
 u32 min_interval;
 u32 max_interval;
 size_t tmpl_len;
 const u8 *tmpl;
};

/**
 * struct cfg80211_unsol_bcast_probe_resp - Unsolicited broadcast probe
 * response parameters in 6GHz.
 *
 * @update: Set to true if the feature configuration should be updated.
 * @interval: Packet interval in TUs. Maximum allowed is 20 TU, as mentioned
 * in IEEE P802.11ax/D6.0 26.17.2.3.2 - AP behavior for fast passive
 * scanning
 * @tmpl_len: Template length
 * @tmpl: Template data for probe response
 */
struct cfg80211_unsol_bcast_probe_resp {
 bool update;
 u32 interval;
 size_t tmpl_len;
 const u8 *tmpl;
};

/**
 * struct cfg80211_s1g_short_beacon - S1G short beacon data.
 *
 * @update: Set to true if the feature configuration should be updated.
 * @short_head: Short beacon head.
 * @short_tail: Short beacon tail.
 * @short_head_len: Short beacon head len.
 * @short_tail_len: Short beacon tail len.
 */
struct cfg80211_s1g_short_beacon {
 bool update;
 const u8 *short_head;
 const u8 *short_tail;
 size_t short_head_len;
 size_t short_tail_len;
};

/**
 * struct cfg80211_ap_settings - AP configuration
 *
 * Used to configure an AP interface.
 *
 * @chandef: defines the channel to use
 * @beacon: beacon data
 * @beacon_interval: beacon interval
 * @dtim_period: DTIM period
 * @ssid: SSID to be used in the BSS (note: may be %NULL if not provided from
 * user space)
 * @ssid_len: length of @ssid
 * @hidden_ssid: whether to hide the SSID in Beacon/Probe Response frames
 * @crypto: crypto settings
 * @privacy: the BSS uses privacy
 * @auth_type: Authentication type (algorithm)
 * @inactivity_timeout: time in seconds to determine station's inactivity.
 * @p2p_ctwindow: P2P CT Window
 * @p2p_opp_ps: P2P opportunistic PS
 * @acl: ACL configuration used by the drivers which has support for
 * MAC address based access control
 * @pbss: If set, start as a PCP instead of AP. Relevant for DMG
 * networks.
 * @beacon_rate: bitrate to be used for beacons
 * @ht_cap: HT capabilities (or %NULL if HT isn't enabled)
 * @vht_cap: VHT capabilities (or %NULL if VHT isn't enabled)
 * @he_cap: HE capabilities (or %NULL if HE isn't enabled)
 * @eht_cap: EHT capabilities (or %NULL if EHT isn't enabled)
 * @eht_oper: EHT operation IE (or %NULL if EHT isn't enabled)
 * @ht_required: stations must support HT
 * @vht_required: stations must support VHT
 * @twt_responder: Enable Target Wait Time
 * @he_required: stations must support HE
 * @sae_h2e_required: stations must support direct H2E technique in SAE
 * @flags: flags, as defined in &enum nl80211_ap_settings_flags
 * @he_obss_pd: OBSS Packet Detection settings
 * @he_oper: HE operation IE (or %NULL if HE isn't enabled)
 * @fils_discovery: FILS discovery transmission parameters
 * @unsol_bcast_probe_resp: Unsolicited broadcast probe response parameters
 * @mbssid_config: AP settings for multiple bssid
 * @s1g_long_beacon_period: S1G long beacon period
 * @s1g_short_beacon: S1G short beacon data
 */
struct cfg80211_ap_settings {
 struct cfg80211_chan_def chandef;

 struct cfg80211_beacon_data beacon;

 int beacon_interval, dtim_period;
 const u8 *ssid;
 size_t ssid_len;
 enum nl80211_hidden_ssid hidden_ssid;
 struct cfg80211_crypto_settings crypto;
 bool privacy;
 enum nl80211_auth_type auth_type;
 int inactivity_timeout;
 u8 p2p_ctwindow;
 bool p2p_opp_ps;
 const struct cfg80211_acl_data *acl;
 bool pbss;
 struct cfg80211_bitrate_mask beacon_rate;

 const struct ieee80211_ht_cap *ht_cap;
 const struct ieee80211_vht_cap *vht_cap;
 const struct ieee80211_he_cap_elem *he_cap;
 const struct ieee80211_he_operation *he_oper;
 const struct ieee80211_eht_cap_elem *eht_cap;
 const struct ieee80211_eht_operation *eht_oper;
 bool ht_required, vht_required, he_required, sae_h2e_required;
 bool twt_responder;
 u32 flags;
 struct ieee80211_he_obss_pd he_obss_pd;
 struct cfg80211_fils_discovery fils_discovery;
 struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
 struct cfg80211_mbssid_config mbssid_config;
 u8 s1g_long_beacon_period;
 struct cfg80211_s1g_short_beacon s1g_short_beacon;
};


/**
 * struct cfg80211_ap_update - AP configuration update
 *
 * Subset of &struct cfg80211_ap_settings, for updating a running AP.
 *
 * @beacon: beacon data
 * @fils_discovery: FILS discovery transmission parameters
 * @unsol_bcast_probe_resp: Unsolicited broadcast probe response parameters
 * @s1g_short_beacon: S1G short beacon data
 */
struct cfg80211_ap_update {
 struct cfg80211_beacon_data beacon;
 struct cfg80211_fils_discovery fils_discovery;
 struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
 struct cfg80211_s1g_short_beacon s1g_short_beacon;
};

/**
 * struct cfg80211_csa_settings - channel switch settings
 *
 * Used for channel switch
 *
 * @chandef: defines the channel to use after the switch
 * @beacon_csa: beacon data while performing the switch
 * @counter_offsets_beacon: offsets of the counters within the beacon (tail)
 * @counter_offsets_presp: offsets of the counters within the probe response
 * @n_counter_offsets_beacon: number of csa counters the beacon (tail)
 * @n_counter_offsets_presp: number of csa counters in the probe response
 * @beacon_after: beacon data to be used on the new channel
 * @unsol_bcast_probe_resp: Unsolicited broadcast probe response parameters
 * @radar_required: whether radar detection is required on the new channel
 * @block_tx: whether transmissions should be blocked while changing
 * @count: number of beacons until switch
 * @link_id: defines the link on which channel switch is expected during
 * MLO. 0 in case of non-MLO.
 */
struct cfg80211_csa_settings {
 struct cfg80211_chan_def chandef;
 struct cfg80211_beacon_data beacon_csa;
 const u16 *counter_offsets_beacon;
 const u16 *counter_offsets_presp;
 unsigned int n_counter_offsets_beacon;
 unsigned int n_counter_offsets_presp;
 struct cfg80211_beacon_data beacon_after;
 struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
 bool radar_required;
 bool block_tx;
 u8 count;
 u8 link_id;
};

/**
 * struct cfg80211_color_change_settings - color change settings
 *
 * Used for bss color change
 *
 * @beacon_color_change: beacon data while performing the color countdown
 * @counter_offset_beacon: offsets of the counters within the beacon (tail)
 * @counter_offset_presp: offsets of the counters within the probe response
 * @beacon_next: beacon data to be used after the color change
 * @unsol_bcast_probe_resp: Unsolicited broadcast probe response parameters
 * @count: number of beacons until the color change
 * @color: the color used after the change
 * @link_id: defines the link on which color change is expected during MLO.
 * 0 in case of non-MLO.
 */
struct cfg80211_color_change_settings {
 struct cfg80211_beacon_data beacon_color_change;
 u16 counter_offset_beacon;
 u16 counter_offset_presp;
 struct cfg80211_beacon_data beacon_next;
 struct cfg80211_unsol_bcast_probe_resp unsol_bcast_probe_resp;
 u8 count;
 u8 color;
 u8 link_id;
};

/**
 * struct iface_combination_params - input parameters for interface combinations
 *
 * Used to pass interface combination parameters
 *
 * @radio_idx: wiphy radio index or -1 for global
 * @num_different_channels: the number of different channels we want
 * to use for verification
 * @radar_detect: a bitmap where each bit corresponds to a channel
 * width where radar detection is needed, as in the definition of
 * &struct ieee80211_iface_combination.@radar_detect_widths
 * @iftype_num: array with the number of interfaces of each interface
 * type.  The index is the interface type as specified in &enum
 * nl80211_iftype.
 * @new_beacon_int: set this to the beacon interval of a new interface
 * that's not operating yet, if such is to be checked as part of
 * the verification
 */
struct iface_combination_params {
 int radio_idx;
 int num_different_channels;
 u8 radar_detect;
 int iftype_num[NUM_NL80211_IFTYPES];
 u32 new_beacon_int;
};

/**
 * enum station_parameters_apply_mask - station parameter values to apply
 * @STATION_PARAM_APPLY_UAPSD: apply new uAPSD parameters (uapsd_queues, max_sp)
 * @STATION_PARAM_APPLY_CAPABILITY: apply new capability
 * @STATION_PARAM_APPLY_PLINK_STATE: apply new plink state
 *
 * Not all station parameters have in-band "no change" signalling,
 * for those that don't these flags will are used.
 */
enum station_parameters_apply_mask {
 STATION_PARAM_APPLY_UAPSD = BIT(0),
 STATION_PARAM_APPLY_CAPABILITY = BIT(1),
 STATION_PARAM_APPLY_PLINK_STATE = BIT(2),
};

/**
 * struct sta_txpwr - station txpower configuration
 *
 * Used to configure txpower for station.
 *
 * @power: tx power (in dBm) to be used for sending data traffic. If tx power
 * is not provided, the default per-interface tx power setting will be
 * overriding. Driver should be picking up the lowest tx power, either tx
 * power per-interface or per-station.
 * @type: In particular if TPC %type is NL80211_TX_POWER_LIMITED then tx power
 * will be less than or equal to specified from userspace, whereas if TPC
 * %type is NL80211_TX_POWER_AUTOMATIC then it indicates default tx power.
 * NL80211_TX_POWER_FIXED is not a valid configuration option for
 * per peer TPC.
 */
struct sta_txpwr {
 s16 power;
 enum nl80211_tx_power_setting type;
};

/**
 * struct link_station_parameters - link station parameters
 *
 * Used to change and create a new link station.
 *
 * @mld_mac: MAC address of the station
 * @link_id: the link id (-1 for non-MLD station)
 * @link_mac: MAC address of the link
 * @supported_rates: supported rates in IEEE 802.11 format
 * (or NULL for no change)
 * @supported_rates_len: number of supported rates
 * @ht_capa: HT capabilities of station
 * @vht_capa: VHT capabilities of station
 * @opmode_notif: operating mode field from Operating Mode Notification
 * @opmode_notif_used: information if operating mode field is used
 * @he_capa: HE capabilities of station
 * @he_capa_len: the length of the HE capabilities
 * @txpwr: transmit power for an associated station
 * @txpwr_set: txpwr field is set
 * @he_6ghz_capa: HE 6 GHz Band capabilities of station
 * @eht_capa: EHT capabilities of station
 * @eht_capa_len: the length of the EHT capabilities
 * @s1g_capa: S1G capabilities of station
 */
struct link_station_parameters {
 const u8 *mld_mac;
 int link_id;
 const u8 *link_mac;
 const u8 *supported_rates;
 u8 supported_rates_len;
 const struct ieee80211_ht_cap *ht_capa;
 const struct ieee80211_vht_cap *vht_capa;
 u8 opmode_notif;
 bool opmode_notif_used;
 const struct ieee80211_he_cap_elem *he_capa;
 u8 he_capa_len;
 struct sta_txpwr txpwr;
 bool txpwr_set;
 const struct ieee80211_he_6ghz_capa *he_6ghz_capa;
 const struct ieee80211_eht_cap_elem *eht_capa;
 u8 eht_capa_len;
 const struct ieee80211_s1g_cap *s1g_capa;
};

/**
 * struct link_station_del_parameters - link station deletion parameters
 *
 * Used to delete a link station entry (or all stations).
 *
 * @mld_mac: MAC address of the station
 * @link_id: the link id
 */
struct link_station_del_parameters {
 const u8 *mld_mac;
 u32 link_id;
};

/**
 * struct cfg80211_ttlm_params: TID to link mapping parameters
 *
 * Used for setting a TID to link mapping.
 *
 * @dlink: Downlink TID to link mapping, as defined in section 9.4.2.314
 *     (TID-To-Link Mapping element) in Draft P802.11be_D4.0.
 * @ulink: Uplink TID to link mapping, as defined in section 9.4.2.314
 *     (TID-To-Link Mapping element) in Draft P802.11be_D4.0.
 */
struct cfg80211_ttlm_params {
 u16 dlink[8];
 u16 ulink[8];
};

/**
 * struct station_parameters - station parameters
 *
 * Used to change and create a new station.
 *
 * @vlan: vlan interface station should belong to
 * @sta_flags_mask: station flags that changed
 * (bitmask of BIT(%NL80211_STA_FLAG_...))
 * @sta_flags_set: station flags values
 * (bitmask of BIT(%NL80211_STA_FLAG_...))
 * @listen_interval: listen interval or -1 for no change
 * @aid: AID or zero for no change
 * @vlan_id: VLAN ID for station (if nonzero)
 * @peer_aid: mesh peer AID or zero for no change
 * @plink_action: plink action to take
 * @plink_state: set the peer link state for a station
 * @uapsd_queues: bitmap of queues configured for uapsd. same format
 * as the AC bitmap in the QoS info field
 * @max_sp: max Service Period. same format as the MAX_SP in the
 * QoS info field (but already shifted down)
 * @sta_modify_mask: bitmap indicating which parameters changed
 * (for those that don't have a natural "no change" value),
 * see &enum station_parameters_apply_mask
 * @local_pm: local link-specific mesh power save mode (no change when set
 * to unknown)
 * @capability: station capability
 * @ext_capab: extended capabilities of the station
 * @ext_capab_len: number of extended capabilities
 * @supported_channels: supported channels in IEEE 802.11 format
 * @supported_channels_len: number of supported channels
 * @supported_oper_classes: supported oper classes in IEEE 802.11 format
 * @supported_oper_classes_len: number of supported operating classes
 * @support_p2p_ps: information if station supports P2P PS mechanism
 * @airtime_weight: airtime scheduler weight for this station
 * @eml_cap_present: Specifies if EML capabilities field (@eml_cap) is
 * present/updated
 * @eml_cap: EML capabilities of this station
 * @link_sta_params: link related params.
 */
struct station_parameters {
 struct net_device *vlan;
 u32 sta_flags_mask, sta_flags_set;
 u32 sta_modify_mask;
 int listen_interval;
 u16 aid;
 u16 vlan_id;
 u16 peer_aid;
 u8 plink_action;
 u8 plink_state;
 u8 uapsd_queues;
 u8 max_sp;
 enum nl80211_mesh_power_mode local_pm;
 u16 capability;
 const u8 *ext_capab;
 u8 ext_capab_len;
 const u8 *supported_channels;
 u8 supported_channels_len;
 const u8 *supported_oper_classes;
 u8 supported_oper_classes_len;
 int support_p2p_ps;
 u16 airtime_weight;
 bool eml_cap_present;
 u16 eml_cap;
 struct link_station_parameters link_sta_params;
};

/**
 * struct station_del_parameters - station deletion parameters
 *
 * Used to delete a station entry (or all stations).
 *
 * @mac: MAC address of the station to remove or NULL to remove all stations
 * @subtype: Management frame subtype to use for indicating removal
 * (10 = Disassociation, 12 = Deauthentication)
 * @reason_code: Reason code for the Disassociation/Deauthentication frame
 * @link_id: Link ID indicating a link that stations to be flushed must be
 * using; valid only for MLO, but can also be -1 for MLO to really
 * remove all stations.
 */
struct station_del_parameters {
 const u8 *mac;
 u8 subtype;
 u16 reason_code;
 int link_id;
};

/**
 * enum cfg80211_station_type - the type of station being modified
 * @CFG80211_STA_AP_CLIENT: client of an AP interface
 * @CFG80211_STA_AP_CLIENT_UNASSOC: client of an AP interface that is still
 * unassociated (update properties for this type of client is permitted)
 * @CFG80211_STA_AP_MLME_CLIENT: client of an AP interface that has
 * the AP MLME in the device
 * @CFG80211_STA_AP_STA: AP station on managed interface
 * @CFG80211_STA_IBSS: IBSS station
 * @CFG80211_STA_TDLS_PEER_SETUP: TDLS peer on managed interface (dummy entry
 * while TDLS setup is in progress, it moves out of this state when
 * being marked authorized; use this only if TDLS with external setup is
 * supported/used)
 * @CFG80211_STA_TDLS_PEER_ACTIVE: TDLS peer on managed interface (active
 * entry that is operating, has been marked authorized by userspace)
 * @CFG80211_STA_MESH_PEER_KERNEL: peer on mesh interface (kernel managed)
 * @CFG80211_STA_MESH_PEER_USER: peer on mesh interface (user managed)
 */
enum cfg80211_station_type {
 CFG80211_STA_AP_CLIENT,
 CFG80211_STA_AP_CLIENT_UNASSOC,
 CFG80211_STA_AP_MLME_CLIENT,
 CFG80211_STA_AP_STA,
 CFG80211_STA_IBSS,
 CFG80211_STA_TDLS_PEER_SETUP,
 CFG80211_STA_TDLS_PEER_ACTIVE,
 CFG80211_STA_MESH_PEER_KERNEL,
 CFG80211_STA_MESH_PEER_USER,
};

/**
 * cfg80211_check_station_change - validate parameter changes
 * @wiphy: the wiphy this operates on
 * @params: the new parameters for a station
 * @statype: the type of station being modified
 *
 * Utility function for the @change_station driver method. Call this function
 * with the appropriate station type looking up the station (and checking that
 * it exists). It will verify whether the station change is acceptable.
 *
 * Return: 0 if the change is acceptable, otherwise an error code. Note that
 * it may modify the parameters for backward compatibility reasons, so don't
 * use them before calling this.
 */
int cfg80211_check_station_change(struct wiphy *wiphy,
      struct station_parameters *params,
      enum cfg80211_station_type statype);

/**
 * enum rate_info_flags - bitrate info flags
 *
 * Used by the driver to indicate the specific rate transmission
 * type for 802.11n transmissions.
 *
 * @RATE_INFO_FLAGS_MCS: mcs field filled with HT MCS
 * @RATE_INFO_FLAGS_VHT_MCS: mcs field filled with VHT MCS
 * @RATE_INFO_FLAGS_SHORT_GI: 400ns guard interval
 * @RATE_INFO_FLAGS_DMG: 60GHz MCS
 * @RATE_INFO_FLAGS_HE_MCS: HE MCS information
 * @RATE_INFO_FLAGS_EDMG: 60GHz MCS in EDMG mode
 * @RATE_INFO_FLAGS_EXTENDED_SC_DMG: 60GHz extended SC MCS
 * @RATE_INFO_FLAGS_EHT_MCS: EHT MCS information
 * @RATE_INFO_FLAGS_S1G_MCS: MCS field filled with S1G MCS
 */
enum rate_info_flags {
 RATE_INFO_FLAGS_MCS   = BIT(0),
 RATE_INFO_FLAGS_VHT_MCS   = BIT(1),
 RATE_INFO_FLAGS_SHORT_GI  = BIT(2),
 RATE_INFO_FLAGS_DMG   = BIT(3),
 RATE_INFO_FLAGS_HE_MCS   = BIT(4),
 RATE_INFO_FLAGS_EDMG   = BIT(5),
 RATE_INFO_FLAGS_EXTENDED_SC_DMG  = BIT(6),
 RATE_INFO_FLAGS_EHT_MCS   = BIT(7),
 RATE_INFO_FLAGS_S1G_MCS   = BIT(8),
};

/**
 * enum rate_info_bw - rate bandwidth information
 *
 * Used by the driver to indicate the rate bandwidth.
 *
 * @RATE_INFO_BW_5: 5 MHz bandwidth
 * @RATE_INFO_BW_10: 10 MHz bandwidth
 * @RATE_INFO_BW_20: 20 MHz bandwidth
 * @RATE_INFO_BW_40: 40 MHz bandwidth
 * @RATE_INFO_BW_80: 80 MHz bandwidth
 * @RATE_INFO_BW_160: 160 MHz bandwidth
 * @RATE_INFO_BW_HE_RU: bandwidth determined by HE RU allocation
 * @RATE_INFO_BW_320: 320 MHz bandwidth
 * @RATE_INFO_BW_EHT_RU: bandwidth determined by EHT RU allocation
 * @RATE_INFO_BW_1: 1 MHz bandwidth
 * @RATE_INFO_BW_2: 2 MHz bandwidth
 * @RATE_INFO_BW_4: 4 MHz bandwidth
 * @RATE_INFO_BW_8: 8 MHz bandwidth
 * @RATE_INFO_BW_16: 16 MHz bandwidth
 */
enum rate_info_bw {
 RATE_INFO_BW_20 = 0,
 RATE_INFO_BW_5,
 RATE_INFO_BW_10,
 RATE_INFO_BW_40,
 RATE_INFO_BW_80,
 RATE_INFO_BW_160,
 RATE_INFO_BW_HE_RU,
 RATE_INFO_BW_320,
 RATE_INFO_BW_EHT_RU,
 RATE_INFO_BW_1,
 RATE_INFO_BW_2,
 RATE_INFO_BW_4,
 RATE_INFO_BW_8,
 RATE_INFO_BW_16,
};

/**
 * struct rate_info - bitrate information
 *
 * Information about a receiving or transmitting bitrate
 *
 * @flags: bitflag of flags from &enum rate_info_flags
 * @legacy: bitrate in 100kbit/s for 802.11abg
 * @mcs: mcs index if struct describes an HT/VHT/HE/EHT/S1G rate
--> --------------------

--> maximum size reached

--> --------------------