cfg80211.h

Go to the documentation of this file.

#ifndef __NET_CFG80211_H
#define __NET_CFG80211_H
/*
 * 802.11 device and configuration interface
 *
 * Copyright 2006-2010  Johannes Berg <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#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 <net/regulatory.h>

/*
 * wireless hardware capability structures
 */

enum ieee80211_band {
    IEEE80211_BAND_2GHZ = NL80211_BAND_2GHZ,
    IEEE80211_BAND_5GHZ = NL80211_BAND_5GHZ,
    IEEE80211_BAND_60GHZ = NL80211_BAND_60GHZ,

    /* keep last */
    IEEE80211_NUM_BANDS
};

enum ieee80211_channel_flags {
    IEEE80211_CHAN_DISABLED     = 1<<0,
    IEEE80211_CHAN_PASSIVE_SCAN = 1<<1,
    IEEE80211_CHAN_NO_IBSS      = 1<<2,
    IEEE80211_CHAN_RADAR        = 1<<3,
    IEEE80211_CHAN_NO_HT40PLUS  = 1<<4,
    IEEE80211_CHAN_NO_HT40MINUS = 1<<5,
    IEEE80211_CHAN_NO_OFDM      = 1<<6,
};

#define IEEE80211_CHAN_NO_HT40 \
    (IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS)

struct ieee80211_channel {
    enum ieee80211_band band;
    u16 center_freq;
    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 ieee80211_rate_flags {
    IEEE80211_RATE_SHORT_PREAMBLE   = 1<<0,
    IEEE80211_RATE_MANDATORY_A  = 1<<1,
    IEEE80211_RATE_MANDATORY_B  = 1<<2,
    IEEE80211_RATE_MANDATORY_G  = 1<<3,
    IEEE80211_RATE_ERP_G        = 1<<4,
};

struct ieee80211_rate {
    u32 flags;
    u16 bitrate;
    u16 hw_value, hw_value_short;
};

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 {
    bool vht_supported;
    u32 cap; /* use IEEE80211_VHT_CAP_ */
    struct ieee80211_vht_mcs_info vht_mcs;
};

struct ieee80211_supported_band {
    struct ieee80211_channel *channels;
    struct ieee80211_rate *bitrates;
    enum ieee80211_band band;
    int n_channels;
    int n_bitrates;
    struct ieee80211_sta_ht_cap ht_cap;
    struct ieee80211_sta_vht_cap vht_cap;
};

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

struct vif_params {
       int use_4addr;
};

struct key_params {
    u8 *key;
    u8 *seq;
    int key_len;
    int seq_len;
    u32 cipher;
};

enum survey_info_flags {
    SURVEY_INFO_NOISE_DBM = 1<<0,
    SURVEY_INFO_IN_USE = 1<<1,
    SURVEY_INFO_CHANNEL_TIME = 1<<2,
    SURVEY_INFO_CHANNEL_TIME_BUSY = 1<<3,
    SURVEY_INFO_CHANNEL_TIME_EXT_BUSY = 1<<4,
    SURVEY_INFO_CHANNEL_TIME_RX = 1<<5,
    SURVEY_INFO_CHANNEL_TIME_TX = 1<<6,
};

struct survey_info {
    struct ieee80211_channel *channel;
    u64 channel_time;
    u64 channel_time_busy;
    u64 channel_time_ext_busy;
    u64 channel_time_rx;
    u64 channel_time_tx;
    u32 filled;
    s8 noise;
};

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[NL80211_MAX_NR_AKM_SUITES];
    bool control_port;
    __be16 control_port_ethertype;
    bool control_port_no_encrypt;
};

struct cfg80211_beacon_data {
    const u8 *head, *tail;
    const u8 *beacon_ies;
    const u8 *proberesp_ies;
    const u8 *assocresp_ies;
    const u8 *probe_resp;

    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;
};

struct cfg80211_ap_settings {
    struct ieee80211_channel *channel;
    enum nl80211_channel_type channel_type;

    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;
};

enum plink_actions {
    PLINK_ACTION_INVALID,
    PLINK_ACTION_OPEN,
    PLINK_ACTION_BLOCK,
};

enum station_parameters_apply_mask {
    STATION_PARAM_APPLY_UAPSD = BIT(0),
};

struct station_parameters {
    u8 *supported_rates;
    struct net_device *vlan;
    u32 sta_flags_mask, sta_flags_set;
    u32 sta_modify_mask;
    int listen_interval;
    u16 aid;
    u8 supported_rates_len;
    u8 plink_action;
    u8 plink_state;
    struct ieee80211_ht_cap *ht_capa;
    u8 uapsd_queues;
    u8 max_sp;
};

enum station_info_flags {
    STATION_INFO_INACTIVE_TIME  = 1<<0,
    STATION_INFO_RX_BYTES       = 1<<1,
    STATION_INFO_TX_BYTES       = 1<<2,
    STATION_INFO_LLID       = 1<<3,
    STATION_INFO_PLID       = 1<<4,
    STATION_INFO_PLINK_STATE    = 1<<5,
    STATION_INFO_SIGNAL     = 1<<6,
    STATION_INFO_TX_BITRATE     = 1<<7,
    STATION_INFO_RX_PACKETS     = 1<<8,
    STATION_INFO_TX_PACKETS     = 1<<9,
    STATION_INFO_TX_RETRIES     = 1<<10,
    STATION_INFO_TX_FAILED      = 1<<11,
    STATION_INFO_RX_DROP_MISC   = 1<<12,
    STATION_INFO_SIGNAL_AVG     = 1<<13,
    STATION_INFO_RX_BITRATE     = 1<<14,
    STATION_INFO_BSS_PARAM          = 1<<15,
    STATION_INFO_CONNECTED_TIME = 1<<16,
    STATION_INFO_ASSOC_REQ_IES  = 1<<17,
    STATION_INFO_STA_FLAGS      = 1<<18,
    STATION_INFO_BEACON_LOSS_COUNT  = 1<<19,
    STATION_INFO_T_OFFSET       = 1<<20,
};

enum rate_info_flags {
    RATE_INFO_FLAGS_MCS     = 1<<0,
    RATE_INFO_FLAGS_40_MHZ_WIDTH    = 1<<1,
    RATE_INFO_FLAGS_SHORT_GI    = 1<<2,
    RATE_INFO_FLAGS_60G     = 1<<3,
};

struct rate_info {
    u8 flags;
    u8 mcs;
    u16 legacy;
};

enum bss_param_flags {
    BSS_PARAM_FLAGS_CTS_PROT    = 1<<0,
    BSS_PARAM_FLAGS_SHORT_PREAMBLE  = 1<<1,
    BSS_PARAM_FLAGS_SHORT_SLOT_TIME = 1<<2,
};

struct sta_bss_parameters {
    u8 flags;
    u8 dtim_period;
    u16 beacon_interval;
};

struct station_info {
    u32 filled;
    u32 connected_time;
    u32 inactive_time;
    u32 rx_bytes;
    u32 tx_bytes;
    u16 llid;
    u16 plid;
    u8 plink_state;
    s8 signal;
    s8 signal_avg;
    struct rate_info txrate;
    struct rate_info rxrate;
    u32 rx_packets;
    u32 tx_packets;
    u32 tx_retries;
    u32 tx_failed;
    u32 rx_dropped_misc;
    struct sta_bss_parameters bss_param;
    struct nl80211_sta_flag_update sta_flags;

    int generation;

    const u8 *assoc_req_ies;
    size_t assoc_req_ies_len;

    u32 beacon_loss_count;
    s64 t_offset;

    /*
     * Note: Add a new enum station_info_flags value for each new field and
     * use it to check which fields are initialized.
     */
};

enum monitor_flags {
    MONITOR_FLAG_FCSFAIL        = 1<<NL80211_MNTR_FLAG_FCSFAIL,
    MONITOR_FLAG_PLCPFAIL       = 1<<NL80211_MNTR_FLAG_PLCPFAIL,
    MONITOR_FLAG_CONTROL        = 1<<NL80211_MNTR_FLAG_CONTROL,
    MONITOR_FLAG_OTHER_BSS      = 1<<NL80211_MNTR_FLAG_OTHER_BSS,
    MONITOR_FLAG_COOK_FRAMES    = 1<<NL80211_MNTR_FLAG_COOK_FRAMES,
};

enum mpath_info_flags {
    MPATH_INFO_FRAME_QLEN       = BIT(0),
    MPATH_INFO_SN           = BIT(1),
    MPATH_INFO_METRIC       = BIT(2),
    MPATH_INFO_EXPTIME      = BIT(3),
    MPATH_INFO_DISCOVERY_TIMEOUT    = BIT(4),
    MPATH_INFO_DISCOVERY_RETRIES    = BIT(5),
    MPATH_INFO_FLAGS        = BIT(6),
};

struct mpath_info {
    u32 filled;
    u32 frame_qlen;
    u32 sn;
    u32 metric;
    u32 exptime;
    u32 discovery_timeout;
    u8 discovery_retries;
    u8 flags;

    int generation;
};

struct bss_parameters {
    int use_cts_prot;
    int use_short_preamble;
    int use_short_slot_time;
    u8 *basic_rates;
    u8 basic_rates_len;
    int ap_isolate;
    int ht_opmode;
};

struct mesh_config {
    u16 dot11MeshRetryTimeout;
    u16 dot11MeshConfirmTimeout;
    u16 dot11MeshHoldingTimeout;
    u16 dot11MeshMaxPeerLinks;
    u8 dot11MeshMaxRetries;
    u8 dot11MeshTTL;
    u8 element_ttl;
    bool auto_open_plinks;
    u32 dot11MeshNbrOffsetMaxNeighbor;
    u8 dot11MeshHWMPmaxPREQretries;
    u32 path_refresh_time;
    u16 min_discovery_timeout;
    u32 dot11MeshHWMPactivePathTimeout;
    u16 dot11MeshHWMPpreqMinInterval;
    u16 dot11MeshHWMPperrMinInterval;
    u16 dot11MeshHWMPnetDiameterTraversalTime;
    u8 dot11MeshHWMPRootMode;
    u16 dot11MeshHWMPRannInterval;
    bool dot11MeshGateAnnouncementProtocol;
    bool dot11MeshForwarding;
    s32 rssi_threshold;
    u16 ht_opmode;
    u32 dot11MeshHWMPactivePathToRootTimeout;
    u16 dot11MeshHWMProotInterval;
    u16 dot11MeshHWMPconfirmationInterval;
};

struct mesh_setup {
    struct ieee80211_channel *channel;
    enum nl80211_channel_type channel_type;
    const u8 *mesh_id;
    u8 mesh_id_len;
    u8 sync_method;
    u8 path_sel_proto;
    u8 path_metric;
    const u8 *ie;
    u8 ie_len;
    bool is_authenticated;
    bool is_secure;
    int mcast_rate[IEEE80211_NUM_BANDS];
};

struct ieee80211_txq_params {
    enum nl80211_ac ac;
    u16 txop;
    u16 cwmin;
    u16 cwmax;
    u8 aifs;
};

/* from net/wireless.h */
struct wiphy;

struct cfg80211_ssid {
    u8 ssid[IEEE80211_MAX_SSID_LEN];
    u8 ssid_len;
};

struct cfg80211_scan_request {
    struct cfg80211_ssid *ssids;
    int n_ssids;
    u32 n_channels;
    const u8 *ie;
    size_t ie_len;

    u32 rates[IEEE80211_NUM_BANDS];

    struct wireless_dev *wdev;

    /* internal */
    struct wiphy *wiphy;
    bool aborted;
    bool no_cck;

    /* keep last */
    struct ieee80211_channel *channels[0];
};

struct cfg80211_match_set {
    struct cfg80211_ssid ssid;
};

struct cfg80211_sched_scan_request {
    struct cfg80211_ssid *ssids;
    int n_ssids;
    u32 n_channels;
    u32 interval;
    const u8 *ie;
    size_t ie_len;
    struct cfg80211_match_set *match_sets;
    int n_match_sets;
    s32 rssi_thold;

    /* internal */
    struct wiphy *wiphy;
    struct net_device *dev;

    /* keep last */
    struct ieee80211_channel *channels[0];
};

enum cfg80211_signal_type {
    CFG80211_SIGNAL_TYPE_NONE,
    CFG80211_SIGNAL_TYPE_MBM,
    CFG80211_SIGNAL_TYPE_UNSPEC,
};

struct cfg80211_bss {
    struct ieee80211_channel *channel;

    u8 bssid[ETH_ALEN];
    u64 tsf;
    u16 beacon_interval;
    u16 capability;
    u8 *information_elements;
    size_t len_information_elements;
    u8 *beacon_ies;
    size_t len_beacon_ies;
    u8 *proberesp_ies;
    size_t len_proberesp_ies;

    s32 signal;

    void (*free_priv)(struct cfg80211_bss *bss);
    u8 priv[0] __attribute__((__aligned__(sizeof(void *))));
};

const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 ie);


struct cfg80211_auth_request {
    struct cfg80211_bss *bss;
    const u8 *ie;
    size_t ie_len;
    enum nl80211_auth_type auth_type;
    const u8 *key;
    u8 key_len, key_idx;
};

enum cfg80211_assoc_req_flags {
    ASSOC_REQ_DISABLE_HT        = BIT(0),
};

struct cfg80211_assoc_request {
    struct cfg80211_bss *bss;
    const u8 *ie, *prev_bssid;
    size_t ie_len;
    struct cfg80211_crypto_settings crypto;
    bool use_mfp;
    u32 flags;
    struct ieee80211_ht_cap ht_capa;
    struct ieee80211_ht_cap ht_capa_mask;
};

struct cfg80211_deauth_request {
    const u8 *bssid;
    const u8 *ie;
    size_t ie_len;
    u16 reason_code;
    bool local_state_change;
};

struct cfg80211_disassoc_request {
    struct cfg80211_bss *bss;
    const u8 *ie;
    size_t ie_len;
    u16 reason_code;
    bool local_state_change;
};

struct cfg80211_ibss_params {
    u8 *ssid;
    u8 *bssid;
    struct ieee80211_channel *channel;
    enum nl80211_channel_type channel_type;
    u8 *ie;
    u8 ssid_len, ie_len;
    u16 beacon_interval;
    u32 basic_rates;
    bool channel_fixed;
    bool privacy;
    bool control_port;
    int mcast_rate[IEEE80211_NUM_BANDS];
};

struct cfg80211_connect_params {
    struct ieee80211_channel *channel;
    u8 *bssid;
    u8 *ssid;
    size_t ssid_len;
    enum nl80211_auth_type auth_type;
    u8 *ie;
    size_t ie_len;
    bool privacy;
    struct cfg80211_crypto_settings crypto;
    const u8 *key;
    u8 key_len, key_idx;
    u32 flags;
    int bg_scan_period;
    struct ieee80211_ht_cap ht_capa;
    struct ieee80211_ht_cap ht_capa_mask;
};

enum wiphy_params_flags {
    WIPHY_PARAM_RETRY_SHORT     = 1 << 0,
    WIPHY_PARAM_RETRY_LONG      = 1 << 1,
    WIPHY_PARAM_FRAG_THRESHOLD  = 1 << 2,
    WIPHY_PARAM_RTS_THRESHOLD   = 1 << 3,
    WIPHY_PARAM_COVERAGE_CLASS  = 1 << 4,
};

/*
 * cfg80211_bitrate_mask - masks for bitrate control
 */
struct cfg80211_bitrate_mask {
    struct {
        u32 legacy;
        u8 mcs[IEEE80211_HT_MCS_MASK_LEN];
    } control[IEEE80211_NUM_BANDS];
};
struct cfg80211_pmksa {
    u8 *bssid;
    u8 *pmkid;
};

struct cfg80211_wowlan_trig_pkt_pattern {
    u8 *mask, *pattern;
    int pattern_len;
};

struct cfg80211_wowlan {
    bool any, disconnect, magic_pkt, gtk_rekey_failure,
         eap_identity_req, four_way_handshake,
         rfkill_release;
    struct cfg80211_wowlan_trig_pkt_pattern *patterns;
    int n_patterns;
};

struct cfg80211_gtk_rekey_data {
    u8 kek[NL80211_KEK_LEN];
    u8 kck[NL80211_KCK_LEN];
    u8 replay_ctr[NL80211_REPLAY_CTR_LEN];
};

struct cfg80211_ops {
    int (*suspend)(struct wiphy *wiphy, struct cfg80211_wowlan *wow);
    int (*resume)(struct wiphy *wiphy);
    void    (*set_wakeup)(struct wiphy *wiphy, bool enabled);

    struct wireless_dev * (*add_virtual_intf)(struct wiphy *wiphy,
                          const char *name,
                          enum nl80211_iftype type,
                          u32 *flags,
                          struct vif_params *params);
    int (*del_virtual_intf)(struct wiphy *wiphy,
                    struct wireless_dev *wdev);
    int (*change_virtual_intf)(struct wiphy *wiphy,
                       struct net_device *dev,
                       enum nl80211_iftype type, u32 *flags,
                       struct vif_params *params);

    int (*add_key)(struct wiphy *wiphy, struct net_device *netdev,
               u8 key_index, bool pairwise, const u8 *mac_addr,
               struct key_params *params);
    int (*get_key)(struct wiphy *wiphy, struct net_device *netdev,
               u8 key_index, bool pairwise, const u8 *mac_addr,
               void *cookie,
               void (*callback)(void *cookie, struct key_params*));
    int (*del_key)(struct wiphy *wiphy, struct net_device *netdev,
               u8 key_index, bool pairwise, const u8 *mac_addr);
    int (*set_default_key)(struct wiphy *wiphy,
                   struct net_device *netdev,
                   u8 key_index, bool unicast, bool multicast);
    int (*set_default_mgmt_key)(struct wiphy *wiphy,
                    struct net_device *netdev,
                    u8 key_index);

    int (*start_ap)(struct wiphy *wiphy, struct net_device *dev,
                struct cfg80211_ap_settings *settings);
    int (*change_beacon)(struct wiphy *wiphy, struct net_device *dev,
                 struct cfg80211_beacon_data *info);
    int (*stop_ap)(struct wiphy *wiphy, struct net_device *dev);


    int (*add_station)(struct wiphy *wiphy, struct net_device *dev,
                   u8 *mac, struct station_parameters *params);
    int (*del_station)(struct wiphy *wiphy, struct net_device *dev,
                   u8 *mac);
    int (*change_station)(struct wiphy *wiphy, struct net_device *dev,
                  u8 *mac, struct station_parameters *params);
    int (*get_station)(struct wiphy *wiphy, struct net_device *dev,
                   u8 *mac, struct station_info *sinfo);
    int (*dump_station)(struct wiphy *wiphy, struct net_device *dev,
                   int idx, u8 *mac, struct station_info *sinfo);

    int (*add_mpath)(struct wiphy *wiphy, struct net_device *dev,
                   u8 *dst, u8 *next_hop);
    int (*del_mpath)(struct wiphy *wiphy, struct net_device *dev,
                   u8 *dst);
    int (*change_mpath)(struct wiphy *wiphy, struct net_device *dev,
                  u8 *dst, u8 *next_hop);
    int (*get_mpath)(struct wiphy *wiphy, struct net_device *dev,
                   u8 *dst, u8 *next_hop,
                   struct mpath_info *pinfo);
    int (*dump_mpath)(struct wiphy *wiphy, struct net_device *dev,
                   int idx, u8 *dst, u8 *next_hop,
                   struct mpath_info *pinfo);
    int (*get_mesh_config)(struct wiphy *wiphy,
                struct net_device *dev,
                struct mesh_config *conf);
    int (*update_mesh_config)(struct wiphy *wiphy,
                      struct net_device *dev, u32 mask,
                      const struct mesh_config *nconf);
    int (*join_mesh)(struct wiphy *wiphy, struct net_device *dev,
                 const struct mesh_config *conf,
                 const struct mesh_setup *setup);
    int (*leave_mesh)(struct wiphy *wiphy, struct net_device *dev);

    int (*change_bss)(struct wiphy *wiphy, struct net_device *dev,
                  struct bss_parameters *params);

    int (*set_txq_params)(struct wiphy *wiphy, struct net_device *dev,
                  struct ieee80211_txq_params *params);

    int (*libertas_set_mesh_channel)(struct wiphy *wiphy,
                         struct net_device *dev,
                         struct ieee80211_channel *chan);

    int (*set_monitor_channel)(struct wiphy *wiphy,
                       struct ieee80211_channel *chan,
                       enum nl80211_channel_type channel_type);

    int (*scan)(struct wiphy *wiphy,
            struct cfg80211_scan_request *request);

    int (*auth)(struct wiphy *wiphy, struct net_device *dev,
            struct cfg80211_auth_request *req);
    int (*assoc)(struct wiphy *wiphy, struct net_device *dev,
             struct cfg80211_assoc_request *req);
    int (*deauth)(struct wiphy *wiphy, struct net_device *dev,
              struct cfg80211_deauth_request *req);
    int (*disassoc)(struct wiphy *wiphy, struct net_device *dev,
                struct cfg80211_disassoc_request *req);

    int (*connect)(struct wiphy *wiphy, struct net_device *dev,
               struct cfg80211_connect_params *sme);
    int (*disconnect)(struct wiphy *wiphy, struct net_device *dev,
                  u16 reason_code);

    int (*join_ibss)(struct wiphy *wiphy, struct net_device *dev,
                 struct cfg80211_ibss_params *params);
    int (*leave_ibss)(struct wiphy *wiphy, struct net_device *dev);

    int (*set_wiphy_params)(struct wiphy *wiphy, u32 changed);

    int (*set_tx_power)(struct wiphy *wiphy,
                enum nl80211_tx_power_setting type, int mbm);
    int (*get_tx_power)(struct wiphy *wiphy, int *dbm);

    int (*set_wds_peer)(struct wiphy *wiphy, struct net_device *dev,
                const u8 *addr);

    void    (*rfkill_poll)(struct wiphy *wiphy);

#ifdef CONFIG_NL80211_TESTMODE
    int (*testmode_cmd)(struct wiphy *wiphy, void *data, int len);
    int (*testmode_dump)(struct wiphy *wiphy, struct sk_buff *skb,
                 struct netlink_callback *cb,
                 void *data, int len);
#endif

    int (*set_bitrate_mask)(struct wiphy *wiphy,
                    struct net_device *dev,
                    const u8 *peer,
                    const struct cfg80211_bitrate_mask *mask);

    int (*dump_survey)(struct wiphy *wiphy, struct net_device *netdev,
            int idx, struct survey_info *info);

    int (*set_pmksa)(struct wiphy *wiphy, struct net_device *netdev,
                 struct cfg80211_pmksa *pmksa);
    int (*del_pmksa)(struct wiphy *wiphy, struct net_device *netdev,
                 struct cfg80211_pmksa *pmksa);
    int (*flush_pmksa)(struct wiphy *wiphy, struct net_device *netdev);

    int (*remain_on_channel)(struct wiphy *wiphy,
                     struct wireless_dev *wdev,
                     struct ieee80211_channel *chan,
                     enum nl80211_channel_type channel_type,
                     unsigned int duration,
                     u64 *cookie);
    int (*cancel_remain_on_channel)(struct wiphy *wiphy,
                        struct wireless_dev *wdev,
                        u64 cookie);

    int (*mgmt_tx)(struct wiphy *wiphy, struct wireless_dev *wdev,
              struct ieee80211_channel *chan, bool offchan,
              enum nl80211_channel_type channel_type,
              bool channel_type_valid, unsigned int wait,
              const u8 *buf, size_t len, bool no_cck,
              bool dont_wait_for_ack, u64 *cookie);
    int (*mgmt_tx_cancel_wait)(struct wiphy *wiphy,
                       struct wireless_dev *wdev,
                       u64 cookie);

    int (*set_power_mgmt)(struct wiphy *wiphy, struct net_device *dev,
                  bool enabled, int timeout);

    int (*set_cqm_rssi_config)(struct wiphy *wiphy,
                       struct net_device *dev,
                       s32 rssi_thold, u32 rssi_hyst);

    int (*set_cqm_txe_config)(struct wiphy *wiphy,
                      struct net_device *dev,
                      u32 rate, u32 pkts, u32 intvl);

    void    (*mgmt_frame_register)(struct wiphy *wiphy,
                       struct wireless_dev *wdev,
                       u16 frame_type, bool reg);

    int (*set_antenna)(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant);
    int (*get_antenna)(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant);

    int (*set_ringparam)(struct wiphy *wiphy, u32 tx, u32 rx);
    void    (*get_ringparam)(struct wiphy *wiphy,
                 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max);

    int (*sched_scan_start)(struct wiphy *wiphy,
                struct net_device *dev,
                struct cfg80211_sched_scan_request *request);
    int (*sched_scan_stop)(struct wiphy *wiphy, struct net_device *dev);

    int (*set_rekey_data)(struct wiphy *wiphy, struct net_device *dev,
                  struct cfg80211_gtk_rekey_data *data);

    int (*tdls_mgmt)(struct wiphy *wiphy, struct net_device *dev,
                 u8 *peer, u8 action_code,  u8 dialog_token,
                 u16 status_code, const u8 *buf, size_t len);
    int (*tdls_oper)(struct wiphy *wiphy, struct net_device *dev,
                 u8 *peer, enum nl80211_tdls_operation oper);

    int (*probe_client)(struct wiphy *wiphy, struct net_device *dev,
                const u8 *peer, u64 *cookie);

    int (*set_noack_map)(struct wiphy *wiphy,
                  struct net_device *dev,
                  u16 noack_map);

    int (*get_et_sset_count)(struct wiphy *wiphy,
                     struct net_device *dev, int sset);
    void    (*get_et_stats)(struct wiphy *wiphy, struct net_device *dev,
                struct ethtool_stats *stats, u64 *data);
    void    (*get_et_strings)(struct wiphy *wiphy, struct net_device *dev,
                  u32 sset, u8 *data);

    struct ieee80211_channel *
        (*get_channel)(struct wiphy *wiphy,
                   struct wireless_dev *wdev,
                   enum nl80211_channel_type *type);

    int (*start_p2p_device)(struct wiphy *wiphy,
                    struct wireless_dev *wdev);
    void    (*stop_p2p_device)(struct wiphy *wiphy,
                   struct wireless_dev *wdev);
};

/*
 * wireless hardware and networking interfaces structures
 * and registration/helper functions
 */

enum wiphy_flags {
    WIPHY_FLAG_CUSTOM_REGULATORY        = BIT(0),
    WIPHY_FLAG_STRICT_REGULATORY        = BIT(1),
    WIPHY_FLAG_DISABLE_BEACON_HINTS     = BIT(2),
    WIPHY_FLAG_NETNS_OK         = BIT(3),
    WIPHY_FLAG_PS_ON_BY_DEFAULT     = BIT(4),
    WIPHY_FLAG_4ADDR_AP         = BIT(5),
    WIPHY_FLAG_4ADDR_STATION        = BIT(6),
    WIPHY_FLAG_CONTROL_PORT_PROTOCOL    = BIT(7),
    WIPHY_FLAG_IBSS_RSN         = BIT(8),
    WIPHY_FLAG_MESH_AUTH            = BIT(10),
    WIPHY_FLAG_SUPPORTS_SCHED_SCAN      = BIT(11),
    /* use hole at 12 */
    WIPHY_FLAG_SUPPORTS_FW_ROAM     = BIT(13),
    WIPHY_FLAG_AP_UAPSD         = BIT(14),
    WIPHY_FLAG_SUPPORTS_TDLS        = BIT(15),
    WIPHY_FLAG_TDLS_EXTERNAL_SETUP      = BIT(16),
    WIPHY_FLAG_HAVE_AP_SME          = BIT(17),
    WIPHY_FLAG_REPORTS_OBSS         = BIT(18),
    WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD    = BIT(19),
    WIPHY_FLAG_OFFCHAN_TX           = BIT(20),
    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL    = BIT(21),
};

struct ieee80211_iface_limit {
    u16 max;
    u16 types;
};

struct ieee80211_iface_combination {
    const struct ieee80211_iface_limit *limits;
    u32 num_different_channels;
    u16 max_interfaces;
    u8 n_limits;
    bool beacon_int_infra_match;
};

struct mac_address {
    u8 addr[ETH_ALEN];
};

struct ieee80211_txrx_stypes {
    u16 tx, rx;
};

enum wiphy_wowlan_support_flags {
    WIPHY_WOWLAN_ANY        = BIT(0),
    WIPHY_WOWLAN_MAGIC_PKT      = BIT(1),
    WIPHY_WOWLAN_DISCONNECT     = BIT(2),
    WIPHY_WOWLAN_SUPPORTS_GTK_REKEY = BIT(3),
    WIPHY_WOWLAN_GTK_REKEY_FAILURE  = BIT(4),
    WIPHY_WOWLAN_EAP_IDENTITY_REQ   = BIT(5),
    WIPHY_WOWLAN_4WAY_HANDSHAKE = BIT(6),
    WIPHY_WOWLAN_RFKILL_RELEASE = BIT(7),
};

struct wiphy_wowlan_support {
    u32 flags;
    int n_patterns;
    int pattern_max_len;
    int pattern_min_len;
};

struct wiphy {
    /* assign these fields before you register the wiphy */

    /* permanent MAC address(es) */
    u8 perm_addr[ETH_ALEN];
    u8 addr_mask[ETH_ALEN];

    struct mac_address *addresses;

    const struct ieee80211_txrx_stypes *mgmt_stypes;

    const struct ieee80211_iface_combination *iface_combinations;
    int n_iface_combinations;
    u16 software_iftypes;

    u16 n_addresses;

    /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */
    u16 interface_modes;

    u32 flags, features;

    u32 ap_sme_capa;

    enum cfg80211_signal_type signal_type;

    int bss_priv_size;
    u8 max_scan_ssids;
    u8 max_sched_scan_ssids;
    u8 max_match_sets;
    u16 max_scan_ie_len;
    u16 max_sched_scan_ie_len;

    int n_cipher_suites;
    const u32 *cipher_suites;

    u8 retry_short;
    u8 retry_long;
    u32 frag_threshold;
    u32 rts_threshold;
    u8 coverage_class;

    char fw_version[ETHTOOL_BUSINFO_LEN];
    u32 hw_version;

#ifdef CONFIG_PM
    struct wiphy_wowlan_support wowlan;
#endif

    u16 max_remain_on_channel_duration;

    u8 max_num_pmkids;

    u32 available_antennas_tx;
    u32 available_antennas_rx;

    /*
     * Bitmap of supported protocols for probe response offloading
     * see &enum nl80211_probe_resp_offload_support_attr. Only valid
     * when the wiphy flag @WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD is set.
     */
    u32 probe_resp_offload;

    /* If multiple wiphys are registered and you're handed e.g.
     * a regular netdev with assigned ieee80211_ptr, you won't
     * know whether it points to a wiphy your driver has registered
     * or not. Assign this to something global to your driver to
     * help determine whether you own this wiphy or not. */
    const void *privid;

    struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS];

    /* Lets us get back the wiphy on the callback */
    int (*reg_notifier)(struct wiphy *wiphy,
                struct regulatory_request *request);

    /* fields below are read-only, assigned by cfg80211 */

    const struct ieee80211_regdomain *regd;

    /* the item in /sys/class/ieee80211/ points to this,
     * you need use set_wiphy_dev() (see below) */
    struct device dev;

    /* protects ->resume, ->suspend sysfs callbacks against unregister hw */
    bool registered;

    /* dir in debugfs: ieee80211/<wiphyname> */
    struct dentry *debugfsdir;

    const struct ieee80211_ht_cap *ht_capa_mod_mask;

#ifdef CONFIG_NET_NS
    /* the network namespace this phy lives in currently */
    struct net *_net;
#endif

#ifdef CONFIG_CFG80211_WEXT
    const struct iw_handler_def *wext;
#endif

    char priv[0] __attribute__((__aligned__(NETDEV_ALIGN)));
};

static inline struct net *wiphy_net(struct wiphy *wiphy)
{
    return read_pnet(&wiphy->_net);
}

static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net)
{
    write_pnet(&wiphy->_net, net);
}

static inline void *wiphy_priv(struct wiphy *wiphy)
{
    BUG_ON(!wiphy);
    return &wiphy->priv;
}

static inline struct wiphy *priv_to_wiphy(void *priv)
{
    BUG_ON(!priv);
    return container_of(priv, struct wiphy, priv);
}

static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev)
{
    wiphy->dev.parent = dev;
}

static inline struct device *wiphy_dev(struct wiphy *wiphy)
{
    return wiphy->dev.parent;
}

static inline const char *wiphy_name(const struct wiphy *wiphy)
{
    return dev_name(&wiphy->dev);
}

struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv);

extern int wiphy_register(struct wiphy *wiphy);

extern void wiphy_unregister(struct wiphy *wiphy);

extern void wiphy_free(struct wiphy *wiphy);

/* internal structs */
struct cfg80211_conn;
struct cfg80211_internal_bss;
struct cfg80211_cached_keys;

struct wireless_dev {
    struct wiphy *wiphy;
    enum nl80211_iftype iftype;

    /* the remainder of this struct should be private to cfg80211 */
    struct list_head list;
    struct net_device *netdev;

    u32 identifier;

    struct list_head mgmt_registrations;
    spinlock_t mgmt_registrations_lock;

    struct mutex mtx;

    struct work_struct cleanup_work;

    bool use_4addr, p2p_started;

    u8 address[ETH_ALEN] __aligned(sizeof(u16));

    /* currently used for IBSS and SME - might be rearranged later */
    u8 ssid[IEEE80211_MAX_SSID_LEN];
    u8 ssid_len, mesh_id_len, mesh_id_up_len;
    enum {
        CFG80211_SME_IDLE,
        CFG80211_SME_CONNECTING,
        CFG80211_SME_CONNECTED,
    } sme_state;
    struct cfg80211_conn *conn;
    struct cfg80211_cached_keys *connect_keys;

    struct list_head event_list;
    spinlock_t event_lock;

    struct cfg80211_internal_bss *current_bss; /* associated / joined */
    struct ieee80211_channel *preset_chan;
    enum nl80211_channel_type preset_chantype;

    /* for AP and mesh channel tracking */
    struct ieee80211_channel *channel;

    bool ibss_fixed;

    bool ps;
    int ps_timeout;

    int beacon_interval;

    u32 ap_unexpected_nlportid;

#ifdef CONFIG_CFG80211_WEXT
    /* wext data */
    struct {
        struct cfg80211_ibss_params ibss;
        struct cfg80211_connect_params connect;
        struct cfg80211_cached_keys *keys;
        u8 *ie;
        size_t ie_len;
        u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
        u8 ssid[IEEE80211_MAX_SSID_LEN];
        s8 default_key, default_mgmt_key;
        bool prev_bssid_valid;
    } wext;
#endif
};

static inline u8 *wdev_address(struct wireless_dev *wdev)
{
    if (wdev->netdev)
        return wdev->netdev->dev_addr;
    return wdev->address;
}

static inline void *wdev_priv(struct wireless_dev *wdev)
{
    BUG_ON(!wdev);
    return wiphy_priv(wdev->wiphy);
}

extern int ieee80211_channel_to_frequency(int chan, enum ieee80211_band band);

extern int ieee80211_frequency_to_channel(int freq);

/*
 * Name indirection necessary because the ieee80211 code also has
 * a function named "ieee80211_get_channel", so if you include
 * cfg80211's header file you get cfg80211's version, if you try
 * to include both header files you'll (rightfully!) get a symbol
 * clash.
 */
extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy,
                             int freq);
static inline struct ieee80211_channel *
ieee80211_get_channel(struct wiphy *wiphy, int freq)
{
    return __ieee80211_get_channel(wiphy, freq);
}

struct ieee80211_rate *
ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
                u32 basic_rates, int bitrate);

/*
 * Radiotap parsing functions -- for controlled injection support
 *
 * Implemented in net/wireless/radiotap.c
 * Documentation in Documentation/networking/radiotap-headers.txt
 */

struct radiotap_align_size {
    uint8_t align:4, size:4;
};

struct ieee80211_radiotap_namespace {
    const struct radiotap_align_size *align_size;
    int n_bits;
    uint32_t oui;
    uint8_t subns;
};

struct ieee80211_radiotap_vendor_namespaces {
    const struct ieee80211_radiotap_namespace *ns;
    int n_ns;
};

struct ieee80211_radiotap_iterator {
    struct ieee80211_radiotap_header *_rtheader;
    const struct ieee80211_radiotap_vendor_namespaces *_vns;
    const struct ieee80211_radiotap_namespace *current_namespace;

    unsigned char *_arg, *_next_ns_data;
    __le32 *_next_bitmap;

    unsigned char *this_arg;
    int this_arg_index;
    int this_arg_size;

    int is_radiotap_ns;

    int _max_length;
    int _arg_index;
    uint32_t _bitmap_shifter;
    int _reset_on_ext;
};

extern int ieee80211_radiotap_iterator_init(
    struct ieee80211_radiotap_iterator *iterator,
    struct ieee80211_radiotap_header *radiotap_header,
    int max_length, const struct ieee80211_radiotap_vendor_namespaces *vns);

extern int ieee80211_radiotap_iterator_next(
    struct ieee80211_radiotap_iterator *iterator);


extern const unsigned char rfc1042_header[6];
extern const unsigned char bridge_tunnel_header[6];

unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb);

unsigned int __attribute_const__ ieee80211_hdrlen(__le16 fc);

unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr);

int ieee80211_data_to_8023(struct sk_buff *skb, const u8 *addr,
               enum nl80211_iftype iftype);

int ieee80211_data_from_8023(struct sk_buff *skb, const u8 *addr,
                 enum nl80211_iftype iftype, u8 *bssid, bool qos);

void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list,
                  const u8 *addr, enum nl80211_iftype iftype,
                  const unsigned int extra_headroom,
                  bool has_80211_header);

unsigned int cfg80211_classify8021d(struct sk_buff *skb);

const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len);

const u8 *cfg80211_find_vendor_ie(unsigned int oui, u8 oui_type,
                  const u8 *ies, int len);

extern int regulatory_hint(struct wiphy *wiphy, const char *alpha2);

extern void wiphy_apply_custom_regulatory(
    struct wiphy *wiphy,
    const struct ieee80211_regdomain *regd);

extern int freq_reg_info(struct wiphy *wiphy,
             u32 center_freq,
             u32 desired_bw_khz,
             const struct ieee80211_reg_rule **reg_rule);

/*
 * callbacks for asynchronous cfg80211 methods, notification
 * functions and BSS handling helpers
 */

void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted);

void cfg80211_sched_scan_results(struct wiphy *wiphy);

void cfg80211_sched_scan_stopped(struct wiphy *wiphy);

struct cfg80211_bss * __must_check
cfg80211_inform_bss_frame(struct wiphy *wiphy,
              struct ieee80211_channel *channel,
              struct ieee80211_mgmt *mgmt, size_t len,
              s32 signal, gfp_t gfp);

struct cfg80211_bss * __must_check
cfg80211_inform_bss(struct wiphy *wiphy,
            struct ieee80211_channel *channel,
            const u8 *bssid, u64 tsf, u16 capability,
            u16 beacon_interval, const u8 *ie, size_t ielen,
            s32 signal, gfp_t gfp);

struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
                      struct ieee80211_channel *channel,
                      const u8 *bssid,
                      const u8 *ssid, size_t ssid_len,
                      u16 capa_mask, u16 capa_val);
static inline struct cfg80211_bss *
cfg80211_get_ibss(struct wiphy *wiphy,
          struct ieee80211_channel *channel,
          const u8 *ssid, size_t ssid_len)
{
    return cfg80211_get_bss(wiphy, channel, NULL, ssid, ssid_len,
                WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS);
}

struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy,
                       struct ieee80211_channel *channel,
                       const u8 *meshid, size_t meshidlen,
                       const u8 *meshcfg);
void cfg80211_ref_bss(struct cfg80211_bss *bss);

void cfg80211_put_bss(struct cfg80211_bss *bss);

void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *bss);

void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len);

void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr);

void cfg80211_send_rx_assoc(struct net_device *dev, struct cfg80211_bss *bss,
                const u8 *buf, size_t len);

void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr);

void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len);

void __cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len);

void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len);

void __cfg80211_send_disassoc(struct net_device *dev, const u8 *buf,
    size_t len);

void cfg80211_send_unprot_deauth(struct net_device *dev, const u8 *buf,
                 size_t len);

void cfg80211_send_unprot_disassoc(struct net_device *dev, const u8 *buf,
                   size_t len);

void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
                  enum nl80211_key_type key_type, int key_id,
                  const u8 *tsc, gfp_t gfp);

void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp);

void cfg80211_notify_new_peer_candidate(struct net_device *dev,
        const u8 *macaddr, const u8 *ie, u8 ie_len, gfp_t gfp);

void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked);

void wiphy_rfkill_start_polling(struct wiphy *wiphy);

void wiphy_rfkill_stop_polling(struct wiphy *wiphy);

#ifdef CONFIG_NL80211_TESTMODE

struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
                          int approxlen);

int cfg80211_testmode_reply(struct sk_buff *skb);

struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
                          int approxlen, gfp_t gfp);

void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp);

#define CFG80211_TESTMODE_CMD(cmd)  .testmode_cmd = (cmd),
#define CFG80211_TESTMODE_DUMP(cmd) .testmode_dump = (cmd),
#else
#define CFG80211_TESTMODE_CMD(cmd)
#define CFG80211_TESTMODE_DUMP(cmd)
#endif

void cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
                 const u8 *req_ie, size_t req_ie_len,
                 const u8 *resp_ie, size_t resp_ie_len,
                 u16 status, gfp_t gfp);

void cfg80211_roamed(struct net_device *dev,
             struct ieee80211_channel *channel,
             const u8 *bssid,
             const u8 *req_ie, size_t req_ie_len,
             const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp);

void cfg80211_roamed_bss(struct net_device *dev, struct cfg80211_bss *bss,
             const u8 *req_ie, size_t req_ie_len,
             const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp);

void cfg80211_disconnected(struct net_device *dev, u16 reason,
               u8 *ie, size_t ie_len, gfp_t gfp);

void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
                   struct ieee80211_channel *chan,
                   enum nl80211_channel_type channel_type,
                   unsigned int duration, gfp_t gfp);

void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
                    struct ieee80211_channel *chan,
                    enum nl80211_channel_type channel_type,
                    gfp_t gfp);


void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
              struct station_info *sinfo, gfp_t gfp);

void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp);

void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
              enum nl80211_connect_failed_reason reason,
              gfp_t gfp);

bool cfg80211_rx_mgmt(struct wireless_dev *wdev, int freq, int sig_dbm,
              const u8 *buf, size_t len, gfp_t gfp);

void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
                 const u8 *buf, size_t len, bool ack, gfp_t gfp);


void cfg80211_cqm_rssi_notify(struct net_device *dev,
                  enum nl80211_cqm_rssi_threshold_event rssi_event,
                  gfp_t gfp);

void cfg80211_cqm_pktloss_notify(struct net_device *dev,
                 const u8 *peer, u32 num_packets, gfp_t gfp);

void cfg80211_cqm_txe_notify(struct net_device *dev, const u8 *peer,
                 u32 num_packets, u32 rate, u32 intvl, gfp_t gfp);

void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
                   const u8 *replay_ctr, gfp_t gfp);

void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
                     const u8 *bssid, bool preauth, gfp_t gfp);

bool cfg80211_rx_spurious_frame(struct net_device *dev,
                const u8 *addr, gfp_t gfp);

bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
                    const u8 *addr, gfp_t gfp);

void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
               u64 cookie, bool acked, gfp_t gfp);

void cfg80211_report_obss_beacon(struct wiphy *wiphy,
                 const u8 *frame, size_t len,
                 int freq, int sig_dbm, gfp_t gfp);

bool cfg80211_can_beacon_sec_chan(struct wiphy *wiphy,
                  struct ieee80211_channel *chan,
                  enum nl80211_channel_type channel_type);

/*
 * cfg80211_ch_switch_notify - update wdev channel and notify userspace
 * @dev: the device which switched channels
 * @freq: new channel frequency (in MHz)
 * @type: channel type
 *
 * Acquires wdev_lock, so must only be called from sleepable driver context!
 */
void cfg80211_ch_switch_notify(struct net_device *dev, int freq,
                   enum nl80211_channel_type type);

/*
 * cfg80211_calculate_bitrate - calculate actual bitrate (in 100Kbps units)
 * @rate: given rate_info to calculate bitrate from
 *
 * return 0 if MCS index >= 32
 */
u32 cfg80211_calculate_bitrate(struct rate_info *rate);

void cfg80211_unregister_wdev(struct wireless_dev *wdev);

/* Logging, debugging and troubleshooting/diagnostic helpers. */

/* wiphy_printk helpers, similar to dev_printk */

#define wiphy_printk(level, wiphy, format, args...)     \
    dev_printk(level, &(wiphy)->dev, format, ##args)
#define wiphy_emerg(wiphy, format, args...)         \
    dev_emerg(&(wiphy)->dev, format, ##args)
#define wiphy_alert(wiphy, format, args...)         \
    dev_alert(&(wiphy)->dev, format, ##args)
#define wiphy_crit(wiphy, format, args...)          \
    dev_crit(&(wiphy)->dev, format, ##args)
#define wiphy_err(wiphy, format, args...)           \
    dev_err(&(wiphy)->dev, format, ##args)
#define wiphy_warn(wiphy, format, args...)          \
    dev_warn(&(wiphy)->dev, format, ##args)
#define wiphy_notice(wiphy, format, args...)            \
    dev_notice(&(wiphy)->dev, format, ##args)
#define wiphy_info(wiphy, format, args...)          \
    dev_info(&(wiphy)->dev, format, ##args)

#define wiphy_debug(wiphy, format, args...)         \
    wiphy_printk(KERN_DEBUG, wiphy, format, ##args)

#define wiphy_dbg(wiphy, format, args...)           \
    dev_dbg(&(wiphy)->dev, format, ##args)

#if defined(VERBOSE_DEBUG)
#define wiphy_vdbg  wiphy_dbg
#else
#define wiphy_vdbg(wiphy, format, args...)              \
({                                  \
    if (0)                              \
        wiphy_printk(KERN_DEBUG, wiphy, format, ##args);    \
    0;                              \
})
#endif

/*
 * wiphy_WARN() acts like wiphy_printk(), but with the key difference
 * of using a WARN/WARN_ON to get the message out, including the
 * file/line information and a backtrace.
 */
#define wiphy_WARN(wiphy, format, args...)          \
    WARN(1, "wiphy: %s\n" format, wiphy_name(wiphy), ##args);

#endif /* __NET_CFG80211_H */