sys/compat/linuxkpi/common/include/net/mac80211.h

   1 /*-
   2  * Copyright (c) 2020-2021 The FreeBSD Foundation
   3  * Copyright (c) 2020-2022 Bjoern A. Zeeb
   4  *
   5  * This software was developed by Björn Zeeb under sponsorship from
   6  * the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31
  32 #ifndef _LINUXKPI_NET_MAC80211_H
  33 #define _LINUXKPI_NET_MAC80211_H
  34
  35 #include <sys/types.h>
  36
  37 #include <asm/atomic64.h>
  38 #include <linux/bitops.h>
  39 #include <linux/etherdevice.h>
  40 #include <linux/ethtool.h>
  41 #include <linux/netdevice.h>
  42 #include <linux/skbuff.h>
  43 #include <linux/workqueue.h>
  44 #include <net/cfg80211.h>
  45
  46 #define ARPHRD_IEEE80211_RADIOTAP               __LINE__ /* XXX TODO brcmfmac */
  47
  48 #define WLAN_OUI_MICROSOFT                      (0x0050F2)
  49 #define WLAN_OUI_TYPE_MICROSOFT_WPA             (1)
  50 #define WLAN_OUI_TYPE_MICROSOFT_TPC             (8)
  51 #define WLAN_OUI_TYPE_WFA_P2P                   (9)
  52 #define WLAN_OUI_WFA                            (0x506F9A)
  53
  54 /* hw->conf.flags */
  55 enum ieee80211_hw_conf_flags {
  56         IEEE80211_CONF_IDLE                     = BIT(0),
  57         IEEE80211_CONF_PS                       = BIT(1),
  58         IEEE80211_CONF_MONITOR                  = BIT(2),
  59 };
  60
  61 /* (*ops->config()) */
  62 enum ieee80211_hw_conf_changed_flags {
  63         IEEE80211_CONF_CHANGE_CHANNEL           = BIT(0),
  64         IEEE80211_CONF_CHANGE_IDLE              = BIT(1),
  65         IEEE80211_CONF_CHANGE_PS                = BIT(2),
  66         IEEE80211_CONF_CHANGE_MONITOR           = BIT(3),
  67 };
  68
  69 #define CFG80211_TESTMODE_CMD(_x)       /* XXX TODO */
  70
  71 #define FCS_LEN                         4
  72
  73 /* ops.configure_filter() */
  74 enum mcast_filter_flags {
  75         FIF_ALLMULTI                    = BIT(0),
  76         FIF_PROBE_REQ                   = BIT(1),
  77         FIF_BCN_PRBRESP_PROMISC         = BIT(2),
  78         FIF_FCSFAIL                     = BIT(3),
  79         FIF_OTHER_BSS                   = BIT(4),
  80         FIF_PSPOLL                      = BIT(5),
  81         FIF_CONTROL                     = BIT(6),
  82 };
  83
  84 enum ieee80211_bss_changed {
  85         BSS_CHANGED_ARP_FILTER          = BIT(0),
  86         BSS_CHANGED_ASSOC               = BIT(1),
  87         BSS_CHANGED_BANDWIDTH           = BIT(2),
  88         BSS_CHANGED_BEACON              = BIT(3),
  89         BSS_CHANGED_BEACON_ENABLED      = BIT(4),
  90         BSS_CHANGED_BEACON_INFO         = BIT(5),
  91         BSS_CHANGED_BEACON_INT          = BIT(6),
  92         BSS_CHANGED_BSSID               = BIT(7),
  93         BSS_CHANGED_CQM                 = BIT(8),
  94         BSS_CHANGED_ERP_CTS_PROT        = BIT(9),
  95         BSS_CHANGED_ERP_SLOT            = BIT(10),
  96         BSS_CHANGED_FTM_RESPONDER       = BIT(11),
  97         BSS_CHANGED_HT                  = BIT(12),
  98         BSS_CHANGED_IDLE                = BIT(13),
  99         BSS_CHANGED_MU_GROUPS           = BIT(14),
 100         BSS_CHANGED_P2P_PS              = BIT(15),
 101         BSS_CHANGED_PS                  = BIT(16),
 102         BSS_CHANGED_QOS                 = BIT(17),
 103         BSS_CHANGED_TXPOWER             = BIT(18),
 104         BSS_CHANGED_HE_BSS_COLOR        = BIT(19),
 105         BSS_CHANGED_AP_PROBE_RESP       = BIT(20),
 106         BSS_CHANGED_BASIC_RATES         = BIT(21),
 107         BSS_CHANGED_ERP_PREAMBLE        = BIT(22),
 108         BSS_CHANGED_IBSS                = BIT(23),
 109         BSS_CHANGED_MCAST_RATE          = BIT(24),
 110         BSS_CHANGED_SSID                = BIT(25),
 111 };
 112
 113 /* 802.11 Figure 9-256 Suite selector format. [OUI(3), SUITE TYPE(1)] */
 114 #define WLAN_CIPHER_SUITE_OUI(_oui, _x) ((_oui) << 8 | (_x) & 0xff)
 115
 116 /* 802.11 Table 9-131 Cipher suite selectors. */
 117 /* 802.1x suite B                       11 */
 118 #define WLAN_CIPHER_SUITE(_x)           WLAN_CIPHER_SUITE_OUI(0x000fac, _x)
 119 /* Use group                            0 */
 120 #define WLAN_CIPHER_SUITE_WEP40         WLAN_CIPHER_SUITE(1)
 121 #define WLAN_CIPHER_SUITE_TKIP          WLAN_CIPHER_SUITE(2)
 122 /* Reserved                             3 */
 123 #define WLAN_CIPHER_SUITE_CCMP          WLAN_CIPHER_SUITE(4)    /* CCMP-128 */
 124 #define WLAN_CIPHER_SUITE_WEP104        WLAN_CIPHER_SUITE(5)
 125 #define WLAN_CIPHER_SUITE_AES_CMAC      WLAN_CIPHER_SUITE(6)    /* BIP-CMAC-128 */
 126 /* Group addressed traffic not allowed  7 */
 127 #define WLAN_CIPHER_SUITE_GCMP          WLAN_CIPHER_SUITE(8)
 128 #define WLAN_CIPHER_SUITE_GCMP_256      WLAN_CIPHER_SUITE(9)
 129 #define WLAN_CIPHER_SUITE_CCMP_256      WLAN_CIPHER_SUITE(10)
 130 #define WLAN_CIPHER_SUITE_BIP_GMAC_128  WLAN_CIPHER_SUITE(11)
 131 #define WLAN_CIPHER_SUITE_BIP_GMAC_256  WLAN_CIPHER_SUITE(12)
 132 #define WLAN_CIPHER_SUITE_BIP_CMAC_256  WLAN_CIPHER_SUITE(13)
 133 /* Reserved                             14-255 */
 134
 135
 136 /* 802.11 Table 9-133 AKM suite selectors. */
 137 #define WLAN_AKM_SUITE(_x)              WLAN_CIPHER_SUITE_OUI(0x000fac, _x)
 138 /* Reserved                             0 */
 139 #define WLAN_AKM_SUITE_8021X            WLAN_AKM_SUITE(1)
 140 #define WLAN_AKM_SUITE_PSK              WLAN_AKM_SUITE(2)
 141 #define WLAN_AKM_SUITE_FT_8021X         WLAN_AKM_SUITE(3)
 142 #define WLAN_AKM_SUITE_FT_PSK           WLAN_AKM_SUITE(4)
 143 #define WLAN_AKM_SUITE_8021X_SHA256     WLAN_AKM_SUITE(5)
 144 #define WLAN_AKM_SUITE_PSK_SHA256       WLAN_AKM_SUITE(6)
 145 /* TDLS                                 7 */
 146 #define WLAN_AKM_SUITE_SAE              WLAN_AKM_SUITE(8)
 147 /* FToSAE                               9 */
 148 /* AP peer key                          10 */
 149 /* 802.1x suite B                       11 */
 150 /* 802.1x suite B 384                   12 */
 151 /* FTo802.1x 384                        13 */
 152 /* Reserved                             14-255 */
 153 /* Apparently 11ax defines more. Seen (19,20) mentioned. */
 154
 155
 156 struct ieee80211_sta;
 157
 158 struct ieee80211_ampdu_params {
 159         /* TODO FIXME */
 160         struct ieee80211_sta                    *sta;
 161         uint8_t                                 tid;
 162         uint16_t                                ssn;
 163         int             action, amsdu, buf_size, timeout;
 164 };
 165
 166 struct ieee80211_bar {
 167         /* TODO FIXME */
 168         int             control, start_seq_num;
 169         uint8_t         *ra;
 170         uint16_t        frame_control;
 171 };
 172
 173 struct ieee80211_p2p_noa_desc {
 174         uint32_t                                count;          /* uint8_t ? */
 175         uint32_t                                duration;
 176         uint32_t                                interval;
 177         uint32_t                                start_time;
 178 };
 179
 180 struct ieee80211_p2p_noa_attr {
 181         uint8_t                                 index;
 182         uint8_t                                 oppps_ctwindow;
 183         struct ieee80211_p2p_noa_desc           desc[4];
 184 };
 185
 186 struct ieee80211_mutable_offsets {
 187         /* TODO FIXME */
 188         uint16_t                                tim_offset;
 189         int     cntdwn_counter_offs;
 190 };
 191
 192 #define WLAN_MEMBERSHIP_LEN                     (8)
 193 #define WLAN_USER_POSITION_LEN                  (16)
 194
 195 struct ieee80211_bss_conf {
 196         /* TODO FIXME */
 197         uint8_t                                 bssid[ETH_ALEN];
 198         uint8_t                                 transmitter_bssid[ETH_ALEN];
 199         struct ieee80211_ftm_responder_params   *ftmr_params;
 200         struct ieee80211_p2p_noa_attr           p2p_noa_attr;
 201         struct cfg80211_chan_def                chandef;
 202         __be32                                  arp_addr_list[1];       /* XXX TODO */
 203         struct ieee80211_rate                   *beacon_rate;
 204         struct {
 205                 uint8_t membership[WLAN_MEMBERSHIP_LEN];
 206                 uint8_t position[WLAN_USER_POSITION_LEN];
 207         }  mu_group;
 208         struct {
 209                 int color;
 210         } he_bss_color;
 211         size_t                                  ssid_len;
 212         uint8_t                                 ssid[IEEE80211_NWID_LEN];
 213         uint16_t                                aid;
 214         uint16_t                                ht_operation_mode;
 215         int                                     arp_addr_cnt;
 216
 217         uint8_t                                 dtim_period;
 218         bool                                    assoc;
 219         bool                                    idle;
 220         bool                                    qos;
 221         bool                                    ps;
 222         bool                                    twt_broadcast;
 223         bool                                    use_cts_prot;
 224         bool                                    use_short_preamble;
 225         bool                                    use_short_slot;
 226         uint16_t                                beacon_int;
 227         uint32_t                                sync_device_ts;
 228         uint64_t                                sync_tsf;
 229         uint8_t                                 sync_dtim_count;
 230         int16_t                                 txpower;
 231         int                                     mcast_rate[NUM_NL80211_BANDS];
 232
 233         int             ack_enabled, bssid_index, bssid_indicator, cqm_rssi_hyst, cqm_rssi_thold, ema_ap, frame_time_rts_th, ftm_responder;
 234         int             htc_trig_based_pkt_ext;
 235         int             multi_sta_back_32bit, nontransmitted;
 236         int             profile_periodicity;
 237         int             twt_requester, uora_exists, uora_ocw_range;
 238         int             assoc_capability, enable_beacon, hidden_ssid, ibss_joined, twt_protected;
 239         int             fils_discovery, he_obss_pd, he_oper, twt_responder, unsol_bcast_probe_resp_interval;
 240         unsigned long   basic_rates;
 241         bool            he_support;
 242 };
 243
 244 struct ieee80211_chanctx_conf {
 245         /* TODO FIXME */
 246         int             rx_chains_dynamic, rx_chains_static;
 247         bool                                    radar_enabled;
 248         struct cfg80211_chan_def                def;
 249         struct cfg80211_chan_def                min_def;
 250
 251         /* Must stay last. */
 252         uint8_t                                 drv_priv[0] __aligned(CACHE_LINE_SIZE);
 253 };
 254
 255 struct ieee80211_channel_switch {
 256         /* TODO FIXME */
 257         int             block_tx, count, delay, device_timestamp, timestamp;
 258         struct cfg80211_chan_def                chandef;
 259 };
 260
 261 struct ieee80211_cipher_scheme {
 262         uint32_t        cipher;
 263         uint8_t         iftype;         /* We do not know the size of this. */
 264         uint8_t         hdr_len;
 265         uint8_t         pn_len;
 266         uint8_t         pn_off;
 267         uint8_t         key_idx_off;
 268         uint8_t         key_idx_mask;
 269         uint8_t         key_idx_shift;
 270         uint8_t         mic_len;
 271 };
 272
 273 enum ieee80211_event_type {
 274         BA_FRAME_TIMEOUT,
 275         BAR_RX_EVENT,
 276         MLME_EVENT,
 277         RSSI_EVENT,
 278 };
 279
 280 enum ieee80211_rssi_event_data {
 281         RSSI_EVENT_LOW,
 282         RSSI_EVENT_HIGH,
 283 };
 284
 285 enum ieee80211_mlme_event_data {
 286         ASSOC_EVENT,
 287         AUTH_EVENT,
 288         DEAUTH_RX_EVENT,
 289         DEAUTH_TX_EVENT,
 290 };
 291
 292 enum ieee80211_mlme_event_status {
 293         MLME_DENIED,
 294         MLME_TIMEOUT,
 295 };
 296
 297 struct ieee80211_mlme_event {
 298         enum ieee80211_mlme_event_data          data;
 299         enum ieee80211_mlme_event_status        status;
 300         int                                     reason;
 301 };
 302
 303 struct ieee80211_event {
 304         /* TODO FIXME */
 305         enum ieee80211_event_type               type;
 306         union {
 307                 struct {
 308                         int     ssn;
 309                         struct ieee80211_sta    *sta;
 310                         uint8_t                 tid;
 311                 } ba;
 312                 struct ieee80211_mlme_event     mlme;
 313         } u;
 314 };
 315
 316 struct ieee80211_ftm_responder_params {
 317         /* TODO FIXME */
 318         uint8_t                                 *lci;
 319         uint8_t                                 *civicloc;
 320         int                                     lci_len;
 321         int                                     civicloc_len;
 322 };
 323
 324 struct ieee80211_he_mu_edca_param_ac_rec {
 325         /* TODO FIXME */
 326         int             aifsn, ecw_min_max, mu_edca_timer;
 327 };
 328
 329 struct ieee80211_conf {
 330         int                                     dynamic_ps_timeout;
 331         uint32_t                                listen_interval;
 332         enum ieee80211_hw_conf_flags            flags;
 333         struct cfg80211_chan_def                chandef;
 334 };
 335
 336 enum ieee80211_hw_flags {
 337         IEEE80211_HW_AMPDU_AGGREGATION,
 338         IEEE80211_HW_AP_LINK_PS,
 339         IEEE80211_HW_BUFF_MMPDU_TXQ,
 340         IEEE80211_HW_CHANCTX_STA_CSA,
 341         IEEE80211_HW_CONNECTION_MONITOR,
 342         IEEE80211_HW_DEAUTH_NEED_MGD_TX_PREP,
 343         IEEE80211_HW_HAS_RATE_CONTROL,
 344         IEEE80211_HW_MFP_CAPABLE,
 345         IEEE80211_HW_NEEDS_UNIQUE_STA_ADDR,
 346         IEEE80211_HW_REPORTS_TX_ACK_STATUS,
 347         IEEE80211_HW_RX_INCLUDES_FCS,
 348         IEEE80211_HW_SIGNAL_DBM,
 349         IEEE80211_HW_SINGLE_SCAN_ON_ALL_BANDS,
 350         IEEE80211_HW_SPECTRUM_MGMT,
 351         IEEE80211_HW_STA_MMPDU_TXQ,
 352         IEEE80211_HW_SUPPORTS_AMSDU_IN_AMPDU,
 353         IEEE80211_HW_SUPPORTS_CLONED_SKBS,
 354         IEEE80211_HW_SUPPORTS_DYNAMIC_PS,
 355         IEEE80211_HW_SUPPORTS_MULTI_BSSID,
 356         IEEE80211_HW_SUPPORTS_ONLY_HE_MULTI_BSSID,
 357         IEEE80211_HW_SUPPORTS_PS,
 358         IEEE80211_HW_SUPPORTS_REORDERING_BUFFER,
 359         IEEE80211_HW_SUPPORTS_VHT_EXT_NSS_BW,
 360         IEEE80211_HW_SUPPORT_FAST_XMIT,
 361         IEEE80211_HW_TDLS_WIDER_BW,
 362         IEEE80211_HW_TIMING_BEACON_ONLY,
 363         IEEE80211_HW_TX_AMPDU_SETUP_IN_HW,
 364         IEEE80211_HW_TX_AMSDU,
 365         IEEE80211_HW_TX_FRAG_LIST,
 366         IEEE80211_HW_USES_RSS,
 367         IEEE80211_HW_WANT_MONITOR_VIF,
 368         IEEE80211_HW_SW_CRYPTO_CONTROL,
 369         IEEE80211_HW_SUPPORTS_TX_FRAG,
 370         IEEE80211_HW_SUPPORTS_TDLS_BUFFER_STA,
 371         IEEE80211_HW_SUPPORTS_PER_STA_GTK,
 372         IEEE80211_HW_REPORTS_LOW_ACK,
 373         IEEE80211_HW_QUEUE_CONTROL,
 374
 375         /* Keep last. */
 376         NUM_IEEE80211_HW_FLAGS
 377 };
 378
 379 struct ieee80211_hw {
 380
 381         struct wiphy                    *wiphy;
 382
 383         /* TODO FIXME */
 384         int             max_rx_aggregation_subframes, max_tx_aggregation_subframes;
 385         int             extra_tx_headroom, weight_multiplier;
 386         int             max_rate_tries, max_rates, max_report_rates;
 387         struct ieee80211_cipher_scheme  *cipher_schemes;
 388         int                             n_cipher_schemes;
 389         const char                      *rate_control_algorithm;
 390         struct {
 391                 uint16_t units_pos;     /* radiotap "spec" is .. inconsistent. */
 392                 uint16_t accuracy;
 393         } radiotap_timestamp;
 394         size_t                          sta_data_size;
 395         size_t                          vif_data_size;
 396         size_t                          chanctx_data_size;
 397         size_t                          txq_data_size;
 398         uint16_t                        radiotap_mcs_details;
 399         uint16_t                        radiotap_vht_details;
 400         uint16_t                        queues;
 401         uint16_t                        offchannel_tx_hw_queue;
 402         uint16_t                        uapsd_max_sp_len;
 403         uint16_t                        uapsd_queues;
 404         uint16_t                        max_tx_fragments;
 405         uint16_t                        max_listen_interval;
 406         netdev_features_t               netdev_features;
 407         unsigned long                   flags[BITS_TO_LONGS(NUM_IEEE80211_HW_FLAGS)];
 408         struct ieee80211_conf           conf;
 409
 410 #if 0   /* leave here for documentation purposes.  This does NOT work. */
 411         /* Must stay last. */
 412         uint8_t                         priv[0] __aligned(CACHE_LINE_SIZE);
 413 #else
 414         void                            *priv;
 415 #endif
 416 };
 417
 418 enum ieee802111_key_flag {
 419         IEEE80211_KEY_FLAG_GENERATE_IV          = BIT(0),
 420         IEEE80211_KEY_FLAG_GENERATE_MMIC        = BIT(1),
 421         IEEE80211_KEY_FLAG_PAIRWISE             = BIT(2),
 422         IEEE80211_KEY_FLAG_PUT_IV_SPACE         = BIT(3),
 423         IEEE80211_KEY_FLAG_PUT_MIC_SPACE        = BIT(4),
 424         IEEE80211_KEY_FLAG_SW_MGMT_TX           = BIT(5),
 425         IEEE80211_KEY_FLAG_GENERATE_IV_MGMT     = BIT(6),
 426 };
 427
 428 struct ieee80211_key_conf {
 429         atomic64_t                      tx_pn;
 430         uint32_t                        cipher;
 431         uint8_t                         icv_len;        /* __unused nowadays? */
 432         uint8_t                         iv_len;
 433         uint8_t                         hw_key_idx;     /* Set by drv. */
 434         uint8_t                         keyidx;
 435         uint16_t                        flags;
 436         uint8_t                         keylen;
 437         uint8_t                         key[0];
 438 };
 439
 440 struct ieee80211_key_seq {
 441         /* TODO FIXME */
 442         union {
 443                 struct {
 444                         uint8_t         seq[IEEE80211_MAX_PN_LEN];
 445                         uint8_t         seq_len;
 446                 } hw;
 447                 struct {
 448                         uint8_t         pn[IEEE80211_CCMP_PN_LEN];
 449                 } ccmp;
 450                 struct {
 451                         uint8_t         pn[IEEE80211_CCMP_PN_LEN];
 452                 } aes_cmac;
 453                 struct {
 454                         uint32_t        iv32;
 455                         uint16_t        iv16;
 456                 } tkip;
 457         };
 458 };
 459
 460
 461 enum ieee80211_rx_status_flags {
 462         RX_FLAG_ALLOW_SAME_PN           = BIT(0),
 463         RX_FLAG_AMPDU_DETAILS           = BIT(1),
 464         RX_FLAG_AMPDU_EOF_BIT           = BIT(2),
 465         RX_FLAG_AMPDU_EOF_BIT_KNOWN     = BIT(3),
 466         RX_FLAG_DECRYPTED               = BIT(4),
 467         RX_FLAG_DUP_VALIDATED           = BIT(5),
 468         RX_FLAG_FAILED_FCS_CRC          = BIT(6),
 469         RX_FLAG_ICV_STRIPPED            = BIT(7),
 470         RX_FLAG_MACTIME_PLCP_START      = BIT(8),
 471         RX_FLAG_MACTIME_START           = BIT(9),
 472         RX_FLAG_MIC_STRIPPED            = BIT(10),
 473         RX_FLAG_MMIC_ERROR              = BIT(11),
 474         RX_FLAG_MMIC_STRIPPED           = BIT(12),
 475         RX_FLAG_NO_PSDU                 = BIT(13),
 476         RX_FLAG_PN_VALIDATED            = BIT(14),
 477         RX_FLAG_RADIOTAP_HE             = BIT(15),
 478         RX_FLAG_RADIOTAP_HE_MU          = BIT(16),
 479         RX_FLAG_RADIOTAP_LSIG           = BIT(17),
 480         RX_FLAG_RADIOTAP_VENDOR_DATA    = BIT(18),
 481         RX_FLAG_NO_SIGNAL_VAL           = BIT(19),
 482         RX_FLAG_IV_STRIPPED             = BIT(20),
 483         RX_FLAG_AMPDU_IS_LAST           = BIT(21),
 484         RX_FLAG_AMPDU_LAST_KNOWN        = BIT(22),
 485         RX_FLAG_AMSDU_MORE              = BIT(23),
 486         RX_FLAG_MACTIME_END             = BIT(24),
 487         RX_FLAG_ONLY_MONITOR            = BIT(25),
 488         RX_FLAG_SKIP_MONITOR            = BIT(26),
 489 };
 490
 491 struct ieee80211_rx_status {
 492         /* TODO FIXME, this is too large. Over-reduce types to u8 where possible. */
 493         uint64_t                        boottime_ns;
 494         uint64_t                        mactime;
 495         uint32_t                        device_timestamp;
 496         enum ieee80211_rx_status_flags  flag;
 497         uint16_t                        freq;
 498         uint8_t                         bw;
 499 #define RATE_INFO_BW_20         0x01
 500 #define RATE_INFO_BW_40         0x02
 501 #define RATE_INFO_BW_80         0x04
 502 #define RATE_INFO_BW_160        0x08
 503 #define RATE_INFO_BW_HE_RU      0x10
 504         uint8_t                         encoding;
 505 #define RX_ENC_LEGACY           0x00
 506 #define RX_ENC_HE               0x01
 507 #define RX_ENC_HT               0x02
 508 #define RX_ENC_VHT              0x04
 509         uint8_t                         ampdu_reference;
 510         uint8_t                         band;
 511         uint8_t                         chains;
 512         uint8_t                         chain_signal[4];
 513         uint8_t                         signal;
 514         uint8_t                         enc_flags;
 515         uint8_t                         he_dcm;
 516         uint8_t                         he_gi;
 517         uint8_t                         he_ru;
 518         uint8_t                         zero_length_psdu_type;
 519         uint8_t                         nss;
 520         uint8_t                         rate_idx;
 521 };
 522
 523 struct ieee80211_scan_ies {
 524         /* TODO FIXME */
 525         int             common_ie_len;
 526         int             len[NUM_NL80211_BANDS];
 527         uint8_t         *common_ies;
 528         uint8_t         *ies[NUM_NL80211_BANDS];
 529 };
 530
 531 struct ieee80211_scan_request {
 532         struct ieee80211_scan_ies       ies;
 533         struct cfg80211_scan_request    req;
 534 };
 535
 536 struct ieee80211_txq {
 537         struct ieee80211_sta            *sta;
 538         struct ieee80211_vif            *vif;
 539         int                             ac;
 540         uint8_t                         tid;
 541
 542         /* Must stay last. */
 543         uint8_t                         drv_priv[0] __aligned(CACHE_LINE_SIZE);
 544 };
 545
 546 struct ieee80211_sta_rates {
 547         /* XXX TODO */
 548         /* XXX some _rcu thing */
 549         struct {
 550                 int     idx;
 551                 int     flags;
 552         } rate[1];              /* XXX what is the real number? */
 553 };
 554
 555 struct ieee80211_sta_txpwr {
 556         /* XXX TODO */
 557         enum nl80211_tx_power_setting   type;
 558         short                           power;
 559 };
 560
 561 #define IEEE80211_NUM_TIDS                      16      /* net80211::WME_NUM_TID */
 562 struct ieee80211_sta {
 563         /* TODO FIXME */
 564         int             max_amsdu_len, max_amsdu_subframes, max_rc_amsdu_len, max_sp;
 565         int             mfp, rx_nss, smps_mode, tdls, tdls_initiator, uapsd_queues, wme;
 566         enum ieee80211_sta_rx_bw                bandwidth;
 567         struct ieee80211_sta_ht_cap             ht_cap;
 568         struct ieee80211_sta_vht_cap            vht_cap;
 569         struct ieee80211_sta_he_cap             he_cap;
 570         struct ieee80211_sta_he_6ghz_capa       he_6ghz_capa;
 571         struct ieee80211_txq                    *txq[IEEE80211_NUM_TIDS + 1];   /* iwlwifi: 8 and adds +1 to tid_data, net80211::IEEE80211_TID_SIZE */
 572         struct ieee80211_sta_rates              *rates; /* some rcu thing? */
 573         struct ieee80211_sta_txpwr              txpwr;
 574         uint32_t                                max_tid_amsdu_len[IEEE80211_NUM_TIDS];
 575         uint32_t                                supp_rates[NUM_NL80211_BANDS];
 576         uint8_t                                 addr[ETH_ALEN];
 577         uint16_t                                aid;
 578
 579         /* Must stay last. */
 580         uint8_t                                 drv_priv[0] __aligned(CACHE_LINE_SIZE);
 581 };
 582
 583 struct ieee80211_tdls_ch_sw_params {
 584         /* TODO FIXME */
 585         int             action_code, ch_sw_tm_ie, status, switch_time, switch_timeout, timestamp;
 586         struct ieee80211_sta                    *sta;
 587         struct cfg80211_chan_def                *chandef;
 588         struct sk_buff                          *tmpl_skb;
 589 };
 590
 591 struct ieee80211_tx_control {
 592         /* TODO FIXME */
 593         struct ieee80211_sta                    *sta;
 594 };
 595
 596 struct ieee80211_tx_queue_params {
 597         /* These types are based on iwlwifi FW structs. */
 598         uint16_t        cw_min;
 599         uint16_t        cw_max;
 600         uint16_t        txop;
 601         uint8_t         aifs;
 602
 603         /* TODO FIXME */
 604         int             acm, mu_edca, uapsd;
 605         struct ieee80211_he_mu_edca_param_ac_rec        mu_edca_param_rec;
 606 };
 607
 608 struct ieee80211_tx_rate {
 609         uint8_t         idx;
 610         uint16_t        count:5,
 611                         flags:11;
 612 };
 613
 614 enum ieee80211_vif_driver_flags {
 615         IEEE80211_VIF_BEACON_FILTER             = BIT(0),
 616         IEEE80211_VIF_SUPPORTS_CQM_RSSI         = BIT(1),
 617         IEEE80211_VIF_SUPPORTS_UAPSD            = BIT(2),
 618 };
 619
 620 struct ieee80211_vif {
 621         /* TODO FIXME */
 622         enum nl80211_iftype             type;
 623         int             csa_active, mu_mimo_owner;
 624         int             cab_queue;
 625         int     color_change_active, offload_flags;
 626         enum ieee80211_vif_driver_flags driver_flags;
 627         bool                            p2p;
 628         bool                            probe_req_reg;
 629         uint8_t                         addr[ETH_ALEN];
 630         struct ieee80211_chanctx_conf   *chanctx_conf;
 631         struct ieee80211_txq            *txq;
 632         struct ieee80211_bss_conf       bss_conf;
 633         uint8_t                         hw_queue[IEEE80211_NUM_ACS];
 634
 635         /* Must stay last. */
 636         uint8_t                         drv_priv[0] __aligned(CACHE_LINE_SIZE);
 637 };
 638
 639 struct ieee80211_vif_chanctx_switch {
 640         struct ieee80211_chanctx_conf   *old_ctx, *new_ctx;
 641         struct ieee80211_vif            *vif;
 642 };
 643
 644 struct ieee80211_prep_tx_info {
 645         u16                             duration;
 646         bool                            success;
 647 };
 648
 649 /* XXX-BZ too big, over-reduce size to u8, and array sizes to minuimum to fit in skb->cb. */
 650 /* Also warning: some sizes change by pointer size!  This is 64bit only. */
 651 struct ieee80211_tx_info {
 652         enum ieee80211_tx_info_flags            flags;
 653         /* TODO FIXME */
 654         u8              band;
 655         u8              hw_queue;
 656         bool            tx_time_est;
 657         union {
 658                 struct {
 659                         struct ieee80211_tx_rate        rates[4];
 660                         bool                            use_rts;
 661                         struct ieee80211_vif            *vif;
 662                         struct ieee80211_key_conf       *hw_key;
 663                         enum ieee80211_tx_control_flags flags;
 664                 } control;
 665                 struct {
 666                         struct ieee80211_tx_rate        rates[4];
 667                         uint32_t                        ack_signal;
 668                         uint8_t                         ampdu_ack_len;
 669                         uint8_t                         ampdu_len;
 670                         uint8_t                         antenna;
 671                         uint16_t                        tx_time;
 672                         bool                            is_valid_ack_signal;
 673                         void                            *status_driver_data[2];         /* XXX TODO */
 674                 } status;
 675 #define IEEE80211_TX_INFO_DRIVER_DATA_SIZE      (5 * sizeof(void *))                    /* XXX TODO 5? */
 676                 void                                    *driver_data[IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *)];
 677         };
 678 };
 679
 680 /* net80211 conflict */
 681 struct linuxkpi_ieee80211_tim_ie {
 682         uint8_t                         dtim_count;
 683         uint8_t                         dtim_period;
 684         uint8_t                         bitmap_ctrl;
 685         uint8_t                         *virtual_map;
 686 };
 687 #define ieee80211_tim_ie        linuxkpi_ieee80211_tim_ie
 688
 689 struct survey_info {            /* net80211::struct ieee80211_channel_survey */
 690         /* TODO FIXME */
 691         uint32_t                        filled;
 692 #define SURVEY_INFO_TIME                0x0001
 693 #define SURVEY_INFO_TIME_RX             0x0002
 694 #define SURVEY_INFO_TIME_SCAN           0x0004
 695 #define SURVEY_INFO_TIME_TX             0x0008
 696 #define SURVEY_INFO_TIME_BSS_RX         0x0010
 697 #define SURVEY_INFO_TIME_BUSY           0x0020
 698 #define SURVEY_INFO_IN_USE              0x0040
 699 #define SURVEY_INFO_NOISE_DBM           0x0080
 700         uint32_t                        noise;
 701         uint64_t                        time;
 702         uint64_t                        time_bss_rx;
 703         uint64_t                        time_busy;
 704         uint64_t                        time_rx;
 705         uint64_t                        time_scan;
 706         uint64_t                        time_tx;
 707         struct ieee80211_channel        *channel;
 708 };
 709
 710 enum ieee80211_iface_iter {
 711         IEEE80211_IFACE_ITER_NORMAL     = BIT(0),
 712         IEEE80211_IFACE_ITER_RESUME_ALL = BIT(1),
 713         IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER = BIT(2),      /* seems to be an iter flag */
 714
 715         /* Internal flags only. */
 716         /* ieee80211_iterate_active_interfaces*(). */
 717         IEEE80211_IFACE_ITER__ATOMIC    = BIT(6),
 718         IEEE80211_IFACE_ITER__ACTIVE    = BIT(7),
 719 };
 720
 721 enum set_key_cmd {
 722         SET_KEY,
 723         DISABLE_KEY,
 724 };
 725
 726 enum rx_enc_flags {
 727         RX_ENC_FLAG_SHORTPRE    =       BIT(0),
 728         RX_ENC_FLAG_SHORT_GI    =       BIT(1),
 729         RX_ENC_FLAG_HT_GF       =       BIT(2),
 730         RX_ENC_FLAG_LDPC        =       BIT(3),
 731         RX_ENC_FLAG_BF          =       BIT(4),
 732 #define RX_ENC_FLAG_STBC_SHIFT          6
 733 };
 734
 735 enum sta_notify_cmd {
 736         STA_NOTIFY_AWAKE,
 737         STA_NOTIFY_SLEEP,
 738 };
 739
 740 struct ieee80211_ops {
 741         /* TODO FIXME */
 742         int  (*start)(struct ieee80211_hw *);
 743         void (*stop)(struct ieee80211_hw *);
 744
 745         int  (*config)(struct ieee80211_hw *, u32);
 746         void (*reconfig_complete)(struct ieee80211_hw *, enum ieee80211_reconfig_type);
 747
 748         int  (*add_interface)(struct ieee80211_hw *, struct ieee80211_vif *);
 749         void (*remove_interface)(struct ieee80211_hw *, struct ieee80211_vif *);
 750         int  (*change_interface)(struct ieee80211_hw *, struct ieee80211_vif *, enum nl80211_iftype, bool);
 751
 752         void (*sw_scan_start)(struct ieee80211_hw *, struct ieee80211_vif *, const u8 *);
 753         void (*sw_scan_complete)(struct ieee80211_hw *, struct ieee80211_vif *);
 754         int  (*sched_scan_start)(struct ieee80211_hw *, struct ieee80211_vif *, struct cfg80211_sched_scan_request *, struct ieee80211_scan_ies *);
 755         int  (*sched_scan_stop)(struct ieee80211_hw *, struct ieee80211_vif *);
 756         int  (*hw_scan)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_scan_request *);
 757         void (*cancel_hw_scan)(struct ieee80211_hw *, struct ieee80211_vif *);
 758
 759         int  (*conf_tx)(struct ieee80211_hw *, struct ieee80211_vif *, u16, const struct ieee80211_tx_queue_params *);
 760         void (*tx)(struct ieee80211_hw *, struct ieee80211_tx_control *, struct sk_buff *);
 761         int  (*tx_last_beacon)(struct ieee80211_hw *);
 762         void (*wake_tx_queue)(struct ieee80211_hw *, struct ieee80211_txq *);
 763
 764         void (*mgd_prepare_tx)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_prep_tx_info *);
 765         void (*mgd_complete_tx)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_prep_tx_info *);
 766         void (*mgd_protect_tdls_discover)(struct ieee80211_hw *, struct ieee80211_vif *);
 767
 768         void (*flush)(struct ieee80211_hw *, struct ieee80211_vif *, u32, bool);
 769
 770         int  (*set_frag_threshold)(struct ieee80211_hw *, u32);
 771
 772         void (*sync_rx_queues)(struct ieee80211_hw *);
 773
 774         void (*allow_buffered_frames)(struct ieee80211_hw *, struct ieee80211_sta *, u16, int, enum ieee80211_frame_release_type, bool);
 775         void (*release_buffered_frames)(struct ieee80211_hw *, struct ieee80211_sta *, u16, int, enum ieee80211_frame_release_type, bool);
 776
 777         int  (*sta_add)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *);
 778         int  (*sta_remove)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *);
 779         int  (*sta_set_txpwr)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *);
 780         void (*sta_statistics)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *, struct station_info *);
 781         void (*sta_pre_rcu_remove)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *);
 782         int  (*sta_state)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *, enum ieee80211_sta_state, enum ieee80211_sta_state);
 783         void (*sta_notify)(struct ieee80211_hw *, struct ieee80211_vif *, enum sta_notify_cmd, struct ieee80211_sta *);
 784         void (*sta_rc_update)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *, u32);
 785         void (*sta_rate_tbl_update)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *);
 786         void (*sta_set_4addr)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *, bool);
 787
 788         u64  (*prepare_multicast)(struct ieee80211_hw *, struct netdev_hw_addr_list *);
 789
 790         int  (*ampdu_action)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_ampdu_params *);
 791
 792         bool (*can_aggregate_in_amsdu)(struct ieee80211_hw *, struct sk_buff *, struct sk_buff *);
 793
 794         int  (*pre_channel_switch)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_channel_switch *);
 795         int  (*post_channel_switch)(struct ieee80211_hw *, struct ieee80211_vif *);
 796         void (*channel_switch)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_channel_switch *);
 797         void (*abort_channel_switch)(struct ieee80211_hw *, struct ieee80211_vif *);
 798         void (*channel_switch_rx_beacon)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_channel_switch *);
 799         int  (*tdls_channel_switch)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *, u8, struct cfg80211_chan_def *, struct sk_buff *, u32);
 800         void (*tdls_cancel_channel_switch)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *);
 801         void (*tdls_recv_channel_switch)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_tdls_ch_sw_params *);
 802
 803         int  (*add_chanctx)(struct ieee80211_hw *, struct ieee80211_chanctx_conf *);
 804         void (*remove_chanctx)(struct ieee80211_hw *, struct ieee80211_chanctx_conf *);
 805         void (*change_chanctx)(struct ieee80211_hw *, struct ieee80211_chanctx_conf *, u32);
 806         int  (*assign_vif_chanctx)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_chanctx_conf *);
 807         void (*unassign_vif_chanctx)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_chanctx_conf *);
 808         int  (*switch_vif_chanctx)(struct ieee80211_hw *, struct ieee80211_vif_chanctx_switch *, int, enum ieee80211_chanctx_switch_mode);
 809
 810         int  (*get_antenna)(struct ieee80211_hw *, u32 *, u32 *);
 811         int  (*set_antenna)(struct ieee80211_hw *, u32, u32);
 812
 813         int  (*remain_on_channel)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_channel *, int, enum ieee80211_roc_type);
 814         int  (*cancel_remain_on_channel)(struct ieee80211_hw *, struct ieee80211_vif *);
 815
 816         void (*configure_filter)(struct ieee80211_hw *, unsigned int, unsigned int *, u64);
 817         void (*config_iface_filter)(struct ieee80211_hw *, struct ieee80211_vif *, unsigned int, unsigned int);
 818
 819         void (*bss_info_changed)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_bss_conf *, u32);
 820         int  (*set_rts_threshold)(struct ieee80211_hw *, u32);
 821         void (*event_callback)(struct ieee80211_hw *, struct ieee80211_vif *, const struct ieee80211_event *);
 822         int  (*get_survey)(struct ieee80211_hw *, int, struct survey_info *);
 823         int  (*get_ftm_responder_stats)(struct ieee80211_hw *, struct ieee80211_vif *, struct cfg80211_ftm_responder_stats *);
 824         void (*offset_tsf)(struct ieee80211_hw *, struct ieee80211_vif *, s64);
 825         int  (*set_bitrate_mask)(struct ieee80211_hw *, struct ieee80211_vif *, const struct cfg80211_bitrate_mask *);
 826         void (*set_coverage_class)(struct ieee80211_hw *, s16);
 827         int  (*set_tim)(struct ieee80211_hw *, struct ieee80211_sta *, bool);
 828
 829         int  (*set_key)(struct ieee80211_hw *, enum set_key_cmd, struct ieee80211_vif *, struct ieee80211_sta *, struct ieee80211_key_conf *);
 830         void (*set_default_unicast_key)(struct ieee80211_hw *, struct ieee80211_vif *, int);
 831         void (*update_tkip_key)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_key_conf *, struct ieee80211_sta *, u32, u16 *);
 832
 833         int  (*start_pmsr)(struct ieee80211_hw *, struct ieee80211_vif *, struct cfg80211_pmsr_request *);
 834         void (*abort_pmsr)(struct ieee80211_hw *, struct ieee80211_vif *, struct cfg80211_pmsr_request *);
 835
 836         int  (*start_ap)(struct ieee80211_hw *, struct ieee80211_vif *);
 837         void (*stop_ap)(struct ieee80211_hw *, struct ieee80211_vif *);
 838         int  (*join_ibss)(struct ieee80211_hw *, struct ieee80211_vif *);
 839         void (*leave_ibss)(struct ieee80211_hw *, struct ieee80211_vif *);
 840
 841         int (*set_sar_specs)(struct ieee80211_hw *, const struct cfg80211_sar_specs *);
 842
 843         int (*set_tid_config)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *, struct cfg80211_tid_config *);
 844         int (*reset_tid_config)(struct ieee80211_hw *, struct ieee80211_vif *, struct ieee80211_sta *, u8);
 845
 846         int (*get_et_sset_count)(struct ieee80211_hw *, struct ieee80211_vif *, int);
 847         void (*get_et_stats)(struct ieee80211_hw *, struct ieee80211_vif *, struct ethtool_stats *, u64 *);
 848         void (*get_et_strings)(struct ieee80211_hw *, struct ieee80211_vif *, u32, u8 *);
 849
 850         void (*update_vif_offload)(struct ieee80211_hw *, struct ieee80211_vif *);
 851 };
 852
 853
 854 /* -------------------------------------------------------------------------- */
 855
 856 /* linux_80211.c */
 857 extern const struct cfg80211_ops linuxkpi_mac80211cfgops;
 858
 859 struct ieee80211_hw *linuxkpi_ieee80211_alloc_hw(size_t,
 860     const struct ieee80211_ops *);
 861 void linuxkpi_ieee80211_iffree(struct ieee80211_hw *);
 862 void linuxkpi_set_ieee80211_dev(struct ieee80211_hw *, char *);
 863 int linuxkpi_ieee80211_ifattach(struct ieee80211_hw *);
 864 void linuxkpi_ieee80211_ifdetach(struct ieee80211_hw *);
 865 struct ieee80211_hw * linuxkpi_wiphy_to_ieee80211_hw(struct wiphy *);
 866 void linuxkpi_ieee80211_iterate_interfaces(
 867     struct ieee80211_hw *hw, enum ieee80211_iface_iter flags,
 868     void(*iterfunc)(void *, uint8_t *, struct ieee80211_vif *),
 869     void *);
 870 void linuxkpi_ieee80211_iterate_keys(struct ieee80211_hw *,
 871     struct ieee80211_vif *,
 872     void(*iterfunc)(struct ieee80211_hw *, struct ieee80211_vif *,
 873         struct ieee80211_sta *, struct ieee80211_key_conf *, void *),
 874     void *);
 875 void linuxkpi_ieee80211_iterate_chan_contexts(struct ieee80211_hw *,
 876     void(*iterfunc)(struct ieee80211_hw *,
 877         struct ieee80211_chanctx_conf *, void *),
 878     void *);
 879 void linuxkpi_ieee80211_iterate_stations_atomic(struct ieee80211_hw *,
 880    void (*iterfunc)(void *, struct ieee80211_sta *), void *);
 881 void linuxkpi_ieee80211_scan_completed(struct ieee80211_hw *,
 882     struct cfg80211_scan_info *);
 883 void linuxkpi_ieee80211_rx(struct ieee80211_hw *, struct sk_buff *,
 884     struct ieee80211_sta *, struct napi_struct *);
 885 uint8_t linuxkpi_ieee80211_get_tid(struct ieee80211_hdr *);
 886 struct ieee80211_sta *linuxkpi_ieee80211_find_sta(struct ieee80211_vif *,
 887     const u8 *);
 888 struct ieee80211_sta *linuxkpi_ieee80211_find_sta_by_ifaddr(
 889     struct ieee80211_hw *, const uint8_t *, const uint8_t *);
 890 struct sk_buff *linuxkpi_ieee80211_tx_dequeue(struct ieee80211_hw *,
 891     struct ieee80211_txq *);
 892 bool linuxkpi_ieee80211_is_ie_id_in_ie_buf(const u8, const u8 *, size_t);
 893 bool linuxkpi_ieee80211_ie_advance(size_t *, const u8 *, size_t);
 894 void linuxkpi_ieee80211_free_txskb(struct ieee80211_hw *, struct sk_buff *,
 895     int);
 896 void linuxkpi_ieee80211_queue_delayed_work(struct ieee80211_hw *,
 897     struct delayed_work *, int);
 898 void linuxkpi_ieee80211_queue_work(struct ieee80211_hw *, struct work_struct *);
 899 struct sk_buff *linuxkpi_ieee80211_pspoll_get(struct ieee80211_hw *,
 900     struct ieee80211_vif *);
 901 struct sk_buff *linuxkpi_ieee80211_nullfunc_get(struct ieee80211_hw *,
 902     struct ieee80211_vif *, bool);
 903 void linuxkpi_ieee80211_txq_get_depth(struct ieee80211_txq *, uint64_t *,
 904     uint64_t *);
 905 struct wireless_dev *linuxkpi_ieee80211_vif_to_wdev(struct ieee80211_vif *);
 906 void linuxkpi_ieee80211_connection_loss(struct ieee80211_vif *);
 907
 908 /* -------------------------------------------------------------------------- */
 909
 910 static __inline void
 911 _ieee80211_hw_set(struct ieee80211_hw *hw, enum ieee80211_hw_flags flag)
 912 {
 913
 914         set_bit(flag, hw->flags);
 915 }
 916
 917 static __inline bool
 918 __ieee80211_hw_check(struct ieee80211_hw *hw, enum ieee80211_hw_flags flag)
 919 {
 920
 921         return (test_bit(flag, hw->flags));
 922 }
 923
 924 /* They pass in shortened flag names; how confusingly inconsistent. */
 925 #define ieee80211_hw_set(_hw, _flag)                                    \
 926         _ieee80211_hw_set(_hw, IEEE80211_HW_ ## _flag)
 927 #define ieee80211_hw_check(_hw, _flag)                                  \
 928         __ieee80211_hw_check(_hw, IEEE80211_HW_ ## _flag)
 929
 930 /* XXX-BZ add CTASSERTS that size of struct is <= sizeof skb->cb. */
 931 CTASSERT(sizeof(struct ieee80211_tx_info) <= sizeof(((struct sk_buff *)0)->cb));
 932 #define IEEE80211_SKB_CB(_skb)                                          \
 933         ((struct ieee80211_tx_info *)((_skb)->cb))
 934
 935 CTASSERT(sizeof(struct ieee80211_rx_status) <= sizeof(((struct sk_buff *)0)->cb));
 936 #define IEEE80211_SKB_RXCB(_skb)                                        \
 937         ((struct ieee80211_rx_status *)((_skb)->cb))
 938
 939 static __inline void
 940 ieee80211_free_hw(struct ieee80211_hw *hw)
 941 {
 942
 943         linuxkpi_ieee80211_iffree(hw);
 944
 945         if (hw->wiphy != NULL)
 946                 wiphy_free(hw->wiphy);
 947         /* Note that *hw is not valid any longer after this. */
 948
 949         IMPROVE();
 950 }
 951
 952 static __inline struct ieee80211_hw *
 953 ieee80211_alloc_hw(size_t priv_len, const struct ieee80211_ops *ops)
 954 {
 955
 956         return (linuxkpi_ieee80211_alloc_hw(priv_len, ops));
 957 }
 958
 959 static __inline void
 960 SET_IEEE80211_DEV(struct ieee80211_hw *hw, struct device *dev)
 961 {
 962
 963         set_wiphy_dev(hw->wiphy, dev);
 964         linuxkpi_set_ieee80211_dev(hw, dev_name(dev));
 965
 966         IMPROVE();
 967 }
 968
 969 static __inline int
 970 ieee80211_register_hw(struct ieee80211_hw *hw)
 971 {
 972         int error;
 973
 974         error = wiphy_register(hw->wiphy);
 975         if (error != 0)
 976                 return (error);
 977
 978         /*
 979          * At this point the driver has set all the options, flags, bands,
 980          * ciphers, hw address(es), ... basically mac80211/cfg80211 hw/wiphy
 981          * setup is done.
 982          * We need to replicate a lot of information from here into net80211.
 983          */
 984         error = linuxkpi_ieee80211_ifattach(hw);
 985
 986         IMPROVE();
 987
 988         return (error);
 989 }
 990
 991 static __inline void
 992 ieee80211_unregister_hw(struct ieee80211_hw *hw)
 993 {
 994
 995         wiphy_unregister(hw->wiphy);
 996         linuxkpi_ieee80211_ifdetach(hw);
 997
 998         IMPROVE();
 999 }
1000
1001 static __inline struct ieee80211_hw *
1002 wiphy_to_ieee80211_hw(struct wiphy *wiphy)
1003 {
1004
1005         return (linuxkpi_wiphy_to_ieee80211_hw(wiphy));
1006 }
1007
1008 /* -------------------------------------------------------------------------- */
1009
1010 static __inline bool
1011 ieee80211_is_action(__le16 fc)
1012 {
1013         __le16 v;
1014
1015         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1016         v = htole16(IEEE80211_FC0_SUBTYPE_ACTION | IEEE80211_FC0_TYPE_MGT);
1017
1018         return (fc == v);
1019 }
1020
1021 static __inline bool
1022 ieee80211_is_probe_resp(__le16 fc)
1023 {
1024         __le16 v;
1025
1026         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1027         v = htole16(IEEE80211_FC0_SUBTYPE_PROBE_RESP | IEEE80211_FC0_TYPE_MGT);
1028
1029         return (fc == v);
1030 }
1031
1032 static __inline bool
1033 ieee80211_is_auth(__le16 fc)
1034 {
1035         __le16 v;
1036
1037         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1038         v = htole16(IEEE80211_FC0_SUBTYPE_AUTH | IEEE80211_FC0_TYPE_MGT);
1039
1040         return (fc == v);
1041 }
1042
1043 static __inline bool
1044 ieee80211_is_assoc_req(__le16 fc)
1045 {
1046         __le16 v;
1047
1048         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1049         v = htole16(IEEE80211_FC0_SUBTYPE_ASSOC_REQ | IEEE80211_FC0_TYPE_MGT);
1050
1051         return (fc == v);
1052 }
1053
1054 static __inline bool
1055 ieee80211_is_assoc_resp(__le16 fc)
1056 {
1057         __le16 v;
1058
1059         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1060         v = htole16(IEEE80211_FC0_SUBTYPE_ASSOC_RESP | IEEE80211_FC0_TYPE_MGT);
1061
1062         return (fc == v);
1063 }
1064
1065 static __inline bool
1066 ieee80211_is_reassoc_req(__le16 fc)
1067 {
1068         __le16 v;
1069
1070         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1071         v = htole16(IEEE80211_FC0_SUBTYPE_REASSOC_REQ | IEEE80211_FC0_TYPE_MGT);
1072
1073         return (fc == v);
1074 }
1075
1076 static __inline bool
1077 ieee80211_is_reassoc_resp(__le16 fc)
1078 {
1079         __le16 v;
1080
1081         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1082         v = htole16(IEEE80211_FC0_SUBTYPE_REASSOC_RESP | IEEE80211_FC0_TYPE_MGT);
1083
1084         return (fc == v);
1085 }
1086
1087 static __inline bool
1088 ieee80211_is_disassoc(__le16 fc)
1089 {
1090         __le16 v;
1091
1092         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1093         v = htole16(IEEE80211_FC0_SUBTYPE_DISASSOC | IEEE80211_FC0_TYPE_MGT);
1094
1095         return (fc == v);
1096 }
1097
1098 static __inline bool
1099 ieee80211_is_data_present(__le16 fc)
1100 {
1101         TODO();
1102         return (false);
1103 }
1104
1105 static __inline bool
1106 ieee80211_is_deauth(__le16 fc)
1107 {
1108         __le16 v;
1109
1110         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1111         v = htole16(IEEE80211_FC0_SUBTYPE_DEAUTH | IEEE80211_FC0_TYPE_MGT);
1112
1113         return (fc == v);
1114 }
1115
1116 static __inline bool
1117 ieee80211_is_beacon(__le16 fc)
1118 {
1119         __le16 v;
1120
1121         /*
1122          * For as much as I get it this comes in LE and unlike FreeBSD
1123          * where we get the entire frame header and u8[], here we get the
1124          * 9.2.4.1 Frame Control field only. Mask and compare.
1125          */
1126         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1127         v = htole16(IEEE80211_FC0_SUBTYPE_BEACON | IEEE80211_FC0_TYPE_MGT);
1128
1129         return (fc == v);
1130 }
1131
1132
1133 static __inline bool
1134 ieee80211_is_probe_req(__le16 fc)
1135 {
1136         __le16 v;
1137
1138         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1139         v = htole16(IEEE80211_FC0_SUBTYPE_PROBE_REQ | IEEE80211_FC0_TYPE_MGT);
1140
1141         return (fc == v);
1142 }
1143
1144 static __inline bool
1145 ieee80211_has_protected(__le16 fc)
1146 {
1147
1148         return (fc & htole16(IEEE80211_FC1_PROTECTED << 8));
1149 }
1150
1151 static __inline bool
1152 ieee80211_is_back_req(__le16 fc)
1153 {
1154         __le16 v;
1155
1156         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1157         v = htole16(IEEE80211_FC0_SUBTYPE_BAR | IEEE80211_FC0_TYPE_CTL);
1158
1159         return (fc == v);
1160 }
1161
1162 static __inline bool
1163 ieee80211_is_bufferable_mmpdu(__le16 fc)
1164 {
1165         TODO();
1166         return (false);
1167 }
1168
1169 static __inline bool
1170 ieee80211_is_nullfunc(__le16 fc)
1171 {
1172         __le16 v;
1173
1174         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1175         v = htole16(IEEE80211_FC0_SUBTYPE_NODATA | IEEE80211_FC0_TYPE_DATA);
1176
1177         return (fc == v);
1178 }
1179
1180 static __inline bool
1181 ieee80211_is_qos_nullfunc(__le16 fc)
1182 {
1183         __le16 v;
1184
1185         fc &= htole16(IEEE80211_FC0_SUBTYPE_MASK | IEEE80211_FC0_TYPE_MASK);
1186         v = htole16(IEEE80211_FC0_SUBTYPE_QOS_NULL | IEEE80211_FC0_TYPE_DATA);
1187
1188         return (fc == v);
1189 }
1190
1191 static __inline bool
1192 ieee80211_is_any_nullfunc(__le16 fc)
1193 {
1194
1195         return (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc));
1196 }
1197
1198 static __inline bool
1199 ieee80211_vif_is_mesh(struct ieee80211_vif *vif)
1200 {
1201         TODO();
1202         return (false);
1203 }
1204
1205 static __inline bool
1206 ieee80211_has_a4(__le16 fc)
1207 {
1208         __le16 v;
1209
1210         fc &= htole16((IEEE80211_FC1_DIR_TODS | IEEE80211_FC1_DIR_FROMDS) << 8);
1211         v = htole16((IEEE80211_FC1_DIR_TODS | IEEE80211_FC1_DIR_FROMDS) << 8);
1212
1213         return (fc == v);
1214 }
1215
1216 static __inline bool
1217 ieee80211_has_order(__le16 fc)
1218 {
1219
1220         return (fc & htole16(IEEE80211_FC1_ORDER << 8));
1221 }
1222
1223 static __inline bool
1224 ieee80211_has_retry(__le16 fc)
1225 {
1226
1227         return (fc & htole16(IEEE80211_FC1_RETRY << 8));
1228 }
1229
1230
1231 static __inline bool
1232 ieee80211_has_fromds(__le16 fc)
1233 {
1234
1235         return (fc & htole16(IEEE80211_FC1_DIR_FROMDS << 8));
1236 }
1237
1238 static __inline bool
1239 ieee80211_has_tods(__le16 fc)
1240 {
1241
1242         return (fc & htole16(IEEE80211_FC1_DIR_TODS << 8));
1243 }
1244
1245 static __inline uint8_t *
1246 ieee80211_get_SA(struct ieee80211_hdr *hdr)
1247 {
1248
1249         if (ieee80211_has_a4(hdr->frame_control))
1250                 return (hdr->addr4);
1251         if (ieee80211_has_fromds(hdr->frame_control))
1252                 return (hdr->addr3);
1253         return (hdr->addr2);
1254 }
1255
1256 static __inline uint8_t *
1257 ieee80211_get_DA(struct ieee80211_hdr *hdr)
1258 {
1259
1260         if (ieee80211_has_tods(hdr->frame_control))
1261                 return (hdr->addr3);
1262         return (hdr->addr1);
1263 }
1264
1265 static __inline bool
1266 ieee80211_has_morefrags(__le16 fc)
1267 {
1268
1269         fc &= htole16(IEEE80211_FC1_MORE_FRAG << 8);
1270         return (fc != 0);
1271 }
1272
1273 static __inline u8 *
1274 ieee80211_get_qos_ctl(struct ieee80211_hdr *hdr)
1275 {
1276         if (ieee80211_has_a4(hdr->frame_control))
1277                 return (u8 *)hdr + 30;
1278         else
1279                 return (u8 *)hdr + 24;
1280 }
1281
1282 /* -------------------------------------------------------------------------- */
1283 /* Receive functions (air/driver to mac80211/net80211). */
1284
1285
1286 static __inline void
1287 ieee80211_rx_napi(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
1288     struct sk_buff *skb, struct napi_struct *napi)
1289 {
1290
1291         linuxkpi_ieee80211_rx(hw, skb, sta, napi);
1292 }
1293
1294 static __inline void
1295 ieee80211_rx_ni(struct ieee80211_hw *hw, struct sk_buff *skb)
1296 {
1297
1298         linuxkpi_ieee80211_rx(hw, skb, NULL, NULL);
1299 }
1300
1301 static __inline void
1302 ieee80211_rx_irqsafe(struct ieee80211_hw *hw, struct sk_buff *skb)
1303 {
1304
1305         linuxkpi_ieee80211_rx(hw, skb, NULL, NULL);
1306 }
1307
1308 /* -------------------------------------------------------------------------- */
1309
1310 static __inline uint8_t
1311 ieee80211_get_tid(struct ieee80211_hdr *hdr)
1312 {
1313
1314         return (linuxkpi_ieee80211_get_tid(hdr));
1315 }
1316
1317 static __inline void
1318 ieee80211_iterate_active_interfaces_atomic(struct ieee80211_hw *hw,
1319     enum ieee80211_iface_iter flags,
1320     void(*iterfunc)(void *, uint8_t *, struct ieee80211_vif *),
1321     void *arg)
1322 {
1323
1324         flags |= IEEE80211_IFACE_ITER__ATOMIC;
1325         flags |= IEEE80211_IFACE_ITER__ACTIVE;
1326         linuxkpi_ieee80211_iterate_interfaces(hw, flags, iterfunc, arg);
1327 }
1328
1329 static __inline void
1330 ieee80211_iterate_active_interfaces(struct ieee80211_hw *hw,
1331     enum ieee80211_iface_iter flags,
1332     void(*iterfunc)(void *, uint8_t *, struct ieee80211_vif *),
1333     void *arg)
1334 {
1335
1336         flags |= IEEE80211_IFACE_ITER__ACTIVE;
1337         linuxkpi_ieee80211_iterate_interfaces(hw, flags, iterfunc, arg);
1338 }
1339
1340 static __inline void
1341 ieee80211_iterate_interfaces(struct ieee80211_hw *hw,
1342    enum ieee80211_iface_iter flags,
1343    void (*iterfunc)(void *, uint8_t *, struct ieee80211_vif *),
1344    void *arg)
1345 {
1346
1347         linuxkpi_ieee80211_iterate_interfaces(hw, flags, iterfunc, arg);
1348 }
1349
1350 static __inline void
1351 ieee80211_iter_keys(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1352     void(*iterfunc)(struct ieee80211_hw *, struct ieee80211_vif *,
1353         struct ieee80211_sta *, struct ieee80211_key_conf *, void *),
1354     void *arg)
1355 {
1356
1357         linuxkpi_ieee80211_iterate_keys(hw, vif, iterfunc, arg);
1358 }
1359
1360 static __inline void
1361 ieee80211_iter_keys_rcu(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1362     void(*iterfunc)(struct ieee80211_hw *, struct ieee80211_vif *,
1363         struct ieee80211_sta *, struct ieee80211_key_conf *, void *),
1364     void *arg)
1365 {
1366
1367         IMPROVE();      /* "rcu" */
1368         linuxkpi_ieee80211_iterate_keys(hw, vif, iterfunc, arg);
1369 }
1370
1371 static __inline void
1372 ieee80211_iter_chan_contexts_atomic(struct ieee80211_hw *hw,
1373     void(*iterfunc)(struct ieee80211_hw *, struct ieee80211_chanctx_conf *, void *),
1374     void *arg)
1375 {
1376
1377         linuxkpi_ieee80211_iterate_chan_contexts(hw, iterfunc, arg);
1378 }
1379
1380 static __inline void
1381 ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw,
1382    void (*iterfunc)(void *, struct ieee80211_sta *), void *arg)
1383 {
1384
1385         linuxkpi_ieee80211_iterate_stations_atomic(hw, iterfunc, arg);
1386 }
1387
1388 static __inline struct wireless_dev *
1389 ieee80211_vif_to_wdev(struct ieee80211_vif *vif)
1390 {
1391
1392         return (linuxkpi_ieee80211_vif_to_wdev(vif));
1393 }
1394
1395 static __inline struct sk_buff *
1396 ieee80211_beacon_get_template(struct ieee80211_hw *hw,
1397     struct ieee80211_vif *vif, struct ieee80211_mutable_offsets *offs)
1398 {
1399         TODO();
1400         return (NULL);
1401 }
1402
1403 static __inline void
1404 ieee80211_beacon_loss(struct ieee80211_vif *vif)
1405 {
1406         TODO();
1407 }
1408
1409 static __inline void
1410 ieee80211_chswitch_done(struct ieee80211_vif *vif, bool t)
1411 {
1412         TODO();
1413 }
1414
1415 static __inline bool
1416 ieee80211_csa_is_complete(struct ieee80211_vif *vif)
1417 {
1418         TODO();
1419         return (false);
1420 }
1421
1422 static __inline void
1423 ieee80211_csa_set_counter(struct ieee80211_vif *vif, uint8_t counter)
1424 {
1425         TODO();
1426 }
1427
1428 static __inline int
1429 ieee80211_csa_update_counter(struct ieee80211_vif *vif)
1430 {
1431         TODO();
1432         return (-1);
1433 }
1434
1435 static __inline void
1436 ieee80211_csa_finish(struct ieee80211_vif *vif)
1437 {
1438         TODO();
1439 }
1440
1441 static __inline enum nl80211_iftype
1442 ieee80211_vif_type_p2p(struct ieee80211_vif *vif)
1443 {
1444
1445         /* If we are not p2p enabled, just return the type. */
1446         if (!vif->p2p)
1447                 return (vif->type);
1448
1449         /* If we are p2p, depending on side, return type. */
1450         switch (vif->type) {
1451         case NL80211_IFTYPE_AP:
1452                 return (NL80211_IFTYPE_P2P_GO);
1453         case NL80211_IFTYPE_STATION:
1454                 return (NL80211_IFTYPE_P2P_CLIENT);
1455         default:
1456                 fallthrough;
1457         }
1458         return (vif->type);
1459 }
1460
1461 static __inline unsigned long
1462 ieee80211_tu_to_usec(unsigned long tu)
1463 {
1464
1465         return (tu * IEEE80211_DUR_TU);
1466 }
1467
1468
1469 static __inline int
1470 ieee80211_action_contains_tpc(struct sk_buff *skb)
1471 {
1472         TODO();
1473         return (0);
1474 }
1475
1476 static __inline void
1477 ieee80211_connection_loss(struct ieee80211_vif *vif)
1478 {
1479
1480         linuxkpi_ieee80211_connection_loss(vif);
1481 }
1482
1483 static __inline struct ieee80211_sta *
1484 ieee80211_find_sta(struct ieee80211_vif *vif, const u8 *peer)
1485 {
1486
1487         return (linuxkpi_ieee80211_find_sta(vif, peer));
1488 }
1489
1490 static __inline struct ieee80211_sta *
1491 ieee80211_find_sta_by_ifaddr(struct ieee80211_hw *hw, const uint8_t *addr,
1492     const uint8_t *ourvifaddr)
1493 {
1494
1495         return (linuxkpi_ieee80211_find_sta_by_ifaddr(hw, addr, ourvifaddr));
1496 }
1497
1498
1499 static __inline void
1500 ieee80211_get_tkip_p2k(struct ieee80211_key_conf *keyconf,
1501     struct sk_buff *skb_frag, u8 *key)
1502 {
1503         TODO();
1504 }
1505
1506 static __inline void
1507 ieee80211_get_tkip_rx_p1k(struct ieee80211_key_conf *keyconf,
1508     const u8 *addr, uint32_t iv32, u16 *p1k)
1509 {
1510         TODO();
1511 }
1512
1513 static __inline size_t
1514 ieee80211_ie_split(const u8 *ies, size_t ies_len,
1515     const u8 *ie_ids, size_t ie_ids_len, size_t start)
1516 {
1517         size_t x;
1518
1519         x = start;
1520
1521         /* XXX FIXME, we need to deal with "Element ID Extension" */
1522         while (x < ies_len) {
1523
1524                 /* Is this IE[s] one of the ie_ids? */
1525                 if (!linuxkpi_ieee80211_is_ie_id_in_ie_buf(ies[x],
1526                     ie_ids, ie_ids_len))
1527                         break;
1528
1529                 if (!linuxkpi_ieee80211_ie_advance(&x, ies, ies_len))
1530                         break;
1531         }
1532
1533         return (x);
1534 }
1535
1536 static __inline void
1537 ieee80211_request_smps(struct ieee80211_vif *vif, enum ieee80211_smps_mode smps)
1538 {
1539
1540         TODO();
1541 }
1542
1543 static __inline void
1544 ieee80211_tdls_oper_request(struct ieee80211_vif *vif, uint8_t *addr,
1545     enum nl80211_tdls_operation oper, enum ieee80211_reason_code code,
1546     gfp_t gfp)
1547 {
1548         TODO();
1549 }
1550
1551 static __inline void
1552 ieee80211_stop_queues(struct ieee80211_hw *hw)
1553 {
1554         TODO();
1555 }
1556
1557 static __inline void
1558 ieee80211_wake_queues(struct ieee80211_hw *hw)
1559 {
1560         TODO();
1561 }
1562
1563 static __inline void
1564 wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool state)
1565 {
1566         TODO();
1567 }
1568
1569 static __inline void
1570 ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb)
1571 {
1572         IMPROVE();
1573
1574         /*
1575          * This is called on transmit failure.
1576          * Use a not-so-random random high status error so we can distinguish
1577          * it from normal low values flying around in net80211 ("ETX").
1578          */
1579         linuxkpi_ieee80211_free_txskb(hw, skb, 0x455458);
1580 }
1581
1582 static __inline void
1583 ieee80211_restart_hw(struct ieee80211_hw *hw)
1584 {
1585         TODO();
1586 }
1587
1588 static __inline void
1589 ieee80211_ready_on_channel(struct ieee80211_hw *hw)
1590 {
1591         TODO();
1592 /* XXX-BZ We need to see that. */
1593 }
1594
1595 static __inline void
1596 ieee80211_remain_on_channel_expired(struct ieee80211_hw *hw)
1597 {
1598         TODO();
1599 }
1600
1601 static __inline void
1602 ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,
1603     enum nl80211_cqm_rssi_threshold_event crte, int sig, gfp_t gfp)
1604 {
1605         TODO();
1606 }
1607
1608 static __inline void
1609 ieee80211_mark_rx_ba_filtered_frames(struct ieee80211_sta *sta, uint8_t tid,
1610     uint32_t ssn, uint64_t bitmap, uint16_t received_mpdu)
1611 {
1612         TODO();
1613 }
1614
1615 static __inline bool
1616 ieee80211_sn_less(uint16_t sn1, uint16_t sn2)
1617 {
1618         TODO();
1619         return (false);
1620 }
1621
1622 static __inline uint16_t
1623 ieee80211_sn_inc(uint16_t sn)
1624 {
1625         TODO();
1626         return (sn + 1);
1627 }
1628
1629 static __inline uint16_t
1630 ieee80211_sn_add(uint16_t sn, uint16_t a)
1631 {
1632         TODO();
1633         return (sn + a);
1634 }
1635
1636 static __inline void
1637 ieee80211_stop_rx_ba_session(struct ieee80211_vif *vif, uint32_t x, uint8_t *addr)
1638 {
1639         TODO();
1640 }
1641
1642 static __inline void
1643 ieee80211_rate_set_vht(struct ieee80211_tx_rate *r, uint32_t f1, uint32_t f2)
1644 {
1645         TODO();
1646 }
1647
1648 static __inline void
1649 ieee80211_reserve_tid(struct ieee80211_sta *sta, uint8_t tid)
1650 {
1651         TODO();
1652 }
1653
1654 static __inline void
1655 ieee80211_unreserve_tid(struct ieee80211_sta *sta, uint8_t tid)
1656 {
1657         TODO();
1658 }
1659
1660 static __inline void
1661 ieee80211_rx_ba_timer_expired(struct ieee80211_vif *vif, uint8_t *addr,
1662     uint8_t tid)
1663 {
1664         TODO();
1665 }
1666
1667 static __inline void
1668 ieee80211_send_eosp_nullfunc(struct ieee80211_sta *sta, uint8_t tid)
1669 {
1670         TODO();
1671 }
1672
1673 static __inline uint16_t
1674 ieee80211_sn_sub(uint16_t sn, uint16_t n)
1675 {
1676         TODO();
1677
1678         return (0);
1679 }
1680
1681 static __inline void
1682 ieee80211_sta_block_awake(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
1683     bool disable)
1684 {
1685         TODO();
1686 }
1687
1688 static __inline void
1689 ieee80211_sta_ps_transition(struct ieee80211_sta *sta, bool sleeping)
1690 {
1691         TODO();
1692 }
1693
1694 static __inline void
1695 ieee80211_sta_pspoll(struct ieee80211_sta *sta)
1696 {
1697         TODO();
1698 }
1699
1700 static __inline void
1701 ieee80211_sta_uapsd_trigger(struct ieee80211_sta *sta, int ntids)
1702 {
1703         TODO();
1704 }
1705
1706 static __inline void
1707 ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif *vif, uint8_t *addr,
1708     uint8_t tid)
1709 {
1710         TODO();
1711 }
1712
1713 static __inline void
1714 ieee80211_tkip_add_iv(u8 *crypto_hdr, struct ieee80211_key_conf *keyconf,
1715     uint64_t pn)
1716 {
1717         TODO();
1718 }
1719
1720 static __inline struct sk_buff *
1721 ieee80211_tx_dequeue(struct ieee80211_hw *hw, struct ieee80211_txq *txq)
1722 {
1723
1724         return (linuxkpi_ieee80211_tx_dequeue(hw, txq));
1725 }
1726
1727 static __inline void
1728 ieee80211_update_mu_groups(struct ieee80211_vif *vif, uint8_t *ms, uint8_t *up)
1729 {
1730         TODO();
1731 }
1732
1733 static __inline void
1734 ieee80211_sta_set_buffered(struct ieee80211_sta *sta, uint8_t tid, bool t)
1735 {
1736         TODO();
1737 }
1738
1739 static __inline void
1740 ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
1741 {
1742         struct ieee80211_tx_info *info;
1743         int status;
1744
1745         info = IEEE80211_SKB_CB(skb);
1746
1747         /* XXX-BZ this check is probably over-simplified? */
1748         /* XXX-BZ but then we have no full feedback in net80211 yet. */
1749         if (info->flags & IEEE80211_TX_STAT_ACK)
1750                 status = 0;     /* No error. */
1751         else
1752                 status = 1;
1753 #if 0
1754         printf("XXX-BZ: %s: hw %p skb %p status %d : flags %#x "
1755             "band %u hw_queue %u tx_time_est %d : "
1756             "rates [ %u %u %#x, %u %u %#x, %u %u %#x, %u %u %#x ] "
1757             "ack_signal %u ampdu_ack_len %u ampdu_len %u antenna %u tx_time %u "
1758             "is_valid_ack_signal %u status_driver_data [ %p %p ]\n",
1759             __func__, hw, skb, status, info->flags,
1760             info->band, info->hw_queue, info->tx_time_est,
1761             info->status.rates[0].idx, info->status.rates[0].count,
1762             info->status.rates[0].flags,
1763             info->status.rates[1].idx, info->status.rates[1].count,
1764             info->status.rates[1].flags,
1765             info->status.rates[2].idx, info->status.rates[2].count,
1766             info->status.rates[2].flags,
1767             info->status.rates[3].idx, info->status.rates[3].count,
1768             info->status.rates[3].flags,
1769             info->status.ack_signal, info->status.ampdu_ack_len,
1770             info->status.ampdu_len, info->status.antenna,
1771             info->status.tx_time, info->status.is_valid_ack_signal,
1772             info->status.status_driver_data[0],
1773             info->status.status_driver_data[1]);
1774 #endif
1775         IMPROVE();
1776         linuxkpi_ieee80211_free_txskb(hw, skb, status);
1777 }
1778
1779 static __inline void
1780 ieee80211_get_key_rx_seq(struct ieee80211_key_conf *keyconf, uint8_t tid,
1781     struct ieee80211_key_seq *seq)
1782 {
1783         TODO();
1784 }
1785
1786 static __inline void
1787 ieee80211_sched_scan_results(struct ieee80211_hw *hw)
1788 {
1789         TODO();
1790 }
1791
1792 static __inline void
1793 ieee80211_sta_eosp(struct ieee80211_sta *sta)
1794 {
1795         TODO();
1796 }
1797
1798 static __inline void
1799 ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif *vif, uint8_t *addr,
1800     uint8_t tid)
1801 {
1802         TODO();
1803 }
1804
1805 static __inline void
1806 ieee80211_sched_scan_stopped(struct ieee80211_hw *hw)
1807 {
1808         TODO();
1809 }
1810
1811 static __inline void
1812 ieee80211_scan_completed(struct ieee80211_hw *hw,
1813     struct cfg80211_scan_info *info)
1814 {
1815
1816         linuxkpi_ieee80211_scan_completed(hw, info);
1817 }
1818
1819 static __inline struct sk_buff *
1820 ieee80211_beacon_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1821 {
1822         TODO();
1823         return (NULL);
1824 }
1825
1826 static __inline struct sk_buff *
1827 ieee80211_pspoll_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1828 {
1829
1830         /* Only STA needs this.  Otherwise return NULL and panic bad drivers. */
1831         if (vif->type != NL80211_IFTYPE_STATION)
1832                 return (NULL);
1833
1834         return (linuxkpi_ieee80211_pspoll_get(hw, vif));
1835 }
1836
1837 static __inline struct sk_buff *
1838 ieee80211_proberesp_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1839 {
1840         TODO();
1841         return (NULL);
1842 }
1843
1844 static __inline struct sk_buff *
1845 ieee80211_nullfunc_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1846     bool qos)
1847 {
1848
1849         /* Only STA needs this.  Otherwise return NULL and panic bad drivers. */
1850         if (vif->type != NL80211_IFTYPE_STATION)
1851                 return (NULL);
1852
1853         return (linuxkpi_ieee80211_nullfunc_get(hw, vif, qos));
1854 }
1855
1856 static __inline struct sk_buff *
1857 ieee80211_probereq_get(struct ieee80211_hw *hw, uint8_t *addr,
1858     uint8_t *ssid, size_t ssid_len, int _x)
1859 {
1860         TODO();
1861         return (NULL);
1862 }
1863
1864 static __inline void
1865 ieee80211_queue_delayed_work(struct ieee80211_hw *hw, struct delayed_work *w,
1866     int delay)
1867 {
1868
1869         linuxkpi_ieee80211_queue_delayed_work(hw, w, delay);
1870 }
1871
1872 static __inline void
1873 ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *w)
1874 {
1875
1876         linuxkpi_ieee80211_queue_work(hw, w);
1877 }
1878
1879 static __inline void
1880 ieee80211_stop_queue(struct ieee80211_hw *hw, uint16_t q)
1881 {
1882         TODO();
1883 }
1884
1885 static __inline void
1886 ieee80211_wake_queue(struct ieee80211_hw *hw, uint16_t q)
1887 {
1888         TODO();
1889 }
1890
1891 static __inline void
1892 ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw, struct sk_buff *skb)
1893 {
1894         IMPROVE();
1895         ieee80211_tx_status(hw, skb);
1896 }
1897
1898 static __inline void
1899 ieee80211_tx_status_ni(struct ieee80211_hw *hw, struct sk_buff *skb)
1900 {
1901         IMPROVE();
1902         ieee80211_tx_status(hw, skb);
1903 }
1904
1905 static __inline int
1906 ieee80211_start_tx_ba_session(struct ieee80211_sta *sta, uint8_t tid, int x)
1907 {
1908         TODO();
1909         return (ENXIO);
1910 }
1911
1912 static __inline void
1913 ieee80211_tx_info_clear_status(struct ieee80211_tx_info *info)
1914 {
1915         int i;
1916
1917         /*
1918          * Apparently clearing flags and some other fields is not right.
1919          * Given the function is called "status" we work on that part of
1920          * the union.
1921          */
1922         for (i = 0; i < nitems(info->status.rates); i++)
1923                 info->status.rates[i].count = 0;
1924         /*
1925          * Unclear if ack_signal should be included or not but we clear the
1926          * "valid" bool so this field is no longer valid.
1927          */
1928         memset(&info->status.ack_signal, 0, sizeof(*info) -
1929             offsetof(struct ieee80211_tx_info, status.ack_signal));
1930 }
1931
1932 static __inline void
1933 ieee80211_txq_get_depth(struct ieee80211_txq *txq, uint64_t *frame_cnt, uint64_t *byte_cnt)
1934 {
1935
1936         if (frame_cnt == NULL && byte_cnt == NULL)
1937                 return;
1938
1939         linuxkpi_ieee80211_txq_get_depth(txq, frame_cnt, byte_cnt);
1940 }
1941
1942 static __inline int
1943 rate_lowest_index(struct ieee80211_supported_band *band,
1944     struct ieee80211_sta *sta)
1945 {
1946         IMPROVE();
1947         return (0);
1948 }
1949
1950
1951 static __inline void
1952 SET_IEEE80211_PERM_ADDR (struct ieee80211_hw *hw, uint8_t *addr)
1953 {
1954
1955         ether_addr_copy(hw->wiphy->perm_addr, addr);
1956 }
1957
1958 static __inline uint8_t *
1959 ieee80211_bss_get_ie(struct cfg80211_bss *bss, uint32_t x)
1960 {
1961         TODO();
1962         return (NULL);
1963 }
1964
1965 static __inline void
1966 ieee80211_report_low_ack(struct ieee80211_sta *sta, int x)
1967 {
1968         TODO();
1969 }
1970
1971 static __inline void
1972 ieee80211_start_rx_ba_session_offl(struct ieee80211_vif *vif, uint8_t *addr,
1973     uint8_t tid)
1974 {
1975         TODO();
1976 }
1977
1978 static __inline void
1979 ieee80211_stop_rx_ba_session_offl(struct ieee80211_vif *vif, uint8_t *addr,
1980     uint8_t tid)
1981 {
1982         TODO();
1983 }
1984
1985 static __inline struct sk_buff *
1986 ieee80211_tx_dequeue_ni(struct ieee80211_hw *hw, struct ieee80211_txq *txq)
1987 {
1988         TODO();
1989         return (NULL);
1990 }
1991
1992 static __inline void
1993 ieee80211_tx_rate_update(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
1994     struct ieee80211_tx_info *info)
1995 {
1996         TODO();
1997 }
1998
1999 static __inline bool
2000 ieee80211_txq_may_transmit(struct ieee80211_hw *hw, struct ieee80211_txq *txq)
2001 {
2002         TODO();
2003         return (false);
2004 }
2005
2006 static __inline struct ieee80211_txq *
2007 ieee80211_next_txq(struct ieee80211_hw *hw, uint32_t ac)
2008 {
2009         TODO();
2010         return (NULL);
2011 }
2012
2013 static __inline void
2014 ieee80211_radar_detected(struct ieee80211_hw *hw)
2015 {
2016         TODO();
2017 }
2018
2019 static __inline void
2020 ieee80211_sta_register_airtime(struct ieee80211_sta *sta,
2021     uint8_t tid, uint32_t duration, int x)
2022 {
2023         TODO();
2024 }
2025
2026
2027 static __inline void
2028 ieee80211_return_txq(struct ieee80211_hw *hw,
2029     struct ieee80211_txq *txq, bool _t)
2030 {
2031         TODO();
2032 }
2033
2034 static __inline void
2035 ieee80211_txq_schedule_end(struct ieee80211_hw *hw, uint32_t ac)
2036 {
2037         TODO();
2038 }
2039
2040 static __inline void
2041 ieee80211_txq_schedule_start(struct ieee80211_hw *hw, uint32_t ac)
2042 {
2043         TODO();
2044 }
2045
2046 static __inline void
2047 ieee80211_schedule_txq(struct ieee80211_hw *hw, struct ieee80211_txq *txq)
2048 {
2049         TODO();
2050 }
2051
2052 static __inline void
2053 ieee80211_beacon_set_cntdwn(struct ieee80211_vif *vif, u8 counter)
2054 {
2055         TODO();
2056 }
2057
2058 static __inline int
2059 ieee80211_beacon_update_cntdwn(struct ieee80211_vif *vif)
2060 {
2061         TODO();
2062         return (-1);
2063 }
2064
2065 static __inline int
2066 ieee80211_get_vht_max_nss(struct ieee80211_vht_cap *vht_cap, uint32_t chanwidth,
2067     int x, bool t, int nss)
2068 {
2069         TODO();
2070         return (-1);
2071 }
2072
2073 static __inline bool
2074 ieee80211_beacon_cntdwn_is_complete(struct ieee80211_vif *vif)
2075 {
2076         TODO();
2077         return (true);
2078 }
2079
2080 static __inline void
2081 ieee80211_disconnect(struct ieee80211_vif *vif, bool _x)
2082 {
2083         TODO();
2084 }
2085
2086 static __inline const struct ieee80211_sta_he_cap *
2087 ieee80211_get_he_iftype_cap(const struct ieee80211_supported_band *band,
2088     enum nl80211_iftype type)
2089 {
2090         TODO();
2091         return (NULL);
2092 }
2093
2094 static __inline void
2095 ieee80211_key_mic_failure(struct ieee80211_key_conf *key)
2096 {
2097         TODO();
2098 }
2099
2100 static __inline void
2101 ieee80211_key_replay(struct ieee80211_key_conf *key)
2102 {
2103         TODO();
2104 }
2105
2106 #endif  /* _LINUXKPI_NET_MAC80211_H */