1 /*- 2 * Copyright (c) 2020-2023 The FreeBSD Foundation 3 * Copyright (c) 2020-2021 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 30 /* 31 * Public functions are called linuxkpi_*(). 32 * Internal (static) functions are called lkpi_*(). 33 * 34 * The internal structures holding metadata over public structures are also 35 * called lkpi_xxx (usually with a member at the end called xxx). 36 * Note: we do not replicate the structure names but the general variable names 37 * for these (e.g., struct hw -> struct lkpi_hw, struct sta -> struct lkpi_sta). 38 * There are macros to access one from the other. 39 * We call the internal versions lxxx (e.g., hw -> lhw, sta -> lsta). 40 */ 41 42 #ifndef _LKPI_SRC_LINUX_80211_H 43 #define _LKPI_SRC_LINUX_80211_H 44 45 #include "opt_wlan.h" 46 47 #if defined(IEEE80211_DEBUG) && !defined(LINUXKPI_DEBUG_80211) 48 #define LINUXKPI_DEBUG_80211 49 #endif 50 51 /* #define LINUXKPI_DEBUG_80211 */ 52 53 #ifndef D80211_TODO 54 #define D80211_TODO 0x00000001 55 #endif 56 #ifndef D80211_IMPROVE 57 #define D80211_IMPROVE 0x00000002 58 #endif 59 #define D80211_IMPROVE_TXQ 0x00000004 60 #define D80211_TRACE 0x00000010 61 #define D80211_TRACEOK 0x00000020 62 #define D80211_TRACE_TX 0x00000100 63 #define D80211_TRACE_TX_DUMP 0x00000200 64 #define D80211_TRACE_RX 0x00001000 65 #define D80211_TRACE_RX_DUMP 0x00002000 66 #define D80211_TRACE_RX_BEACONS 0x00004000 67 #define D80211_TRACEX (D80211_TRACE_TX|D80211_TRACE_RX) 68 #define D80211_TRACEX_DUMP (D80211_TRACE_TX_DUMP|D80211_TRACE_RX_DUMP) 69 #define D80211_TRACE_STA 0x00010000 70 #define D80211_TRACE_HW_CRYPTO 0x00020000 71 #define D80211_TRACE_MO 0x00100000 72 #define D80211_TRACE_MODE 0x0f000000 73 #define D80211_TRACE_MODE_HT 0x01000000 74 #define D80211_TRACE_MODE_VHT 0x02000000 75 #define D80211_TRACE_MODE_HE 0x04000000 76 #define D80211_TRACE_MODE_EHT 0x08000000 77 78 #define IMPROVE_TXQ(...) \ 79 if (linuxkpi_debug_80211 & D80211_IMPROVE_TXQ) \ 80 printf("%s:%d: XXX LKPI80211 IMPROVE_TXQ\n", __func__, __LINE__) 81 82 #define IMPROVE_HT(fmt, ...) \ 83 if (linuxkpi_debug_80211 & D80211_TRACE_MODE_HT) \ 84 printf("%s:%d: XXX LKPI80211 IMPROVE_HT " fmt "\n", \ 85 __func__, __LINE__, ##__VA_ARGS__); 86 87 #define MTAG_ABI_LKPI80211 1707696513 /* LinuxKPI 802.11 KBI */ 88 89 #ifdef LKPI_80211_USE_MTAG 90 /* 91 * Deferred RX path. 92 * We need to pass *ni along (and possibly more in the future so 93 * we use a struct right from the start. 94 */ 95 #define LKPI80211_TAG_RXNI 0 /* deferred RX path */ 96 struct lkpi_80211_tag_rxni { 97 struct ieee80211_node *ni; /* MUST hold a reference to it. */ 98 }; 99 #endif 100 101 struct lkpi_radiotap_tx_hdr { 102 struct ieee80211_radiotap_header wt_ihdr; 103 uint8_t wt_flags; 104 uint8_t wt_rate; 105 uint16_t wt_chan_freq; 106 uint16_t wt_chan_flags; 107 } __packed; 108 #define LKPI_RTAP_TX_FLAGS_PRESENT \ 109 ((1 << IEEE80211_RADIOTAP_FLAGS) | \ 110 (1 << IEEE80211_RADIOTAP_RATE) | \ 111 (1 << IEEE80211_RADIOTAP_CHANNEL)) 112 113 struct lkpi_radiotap_rx_hdr { 114 struct ieee80211_radiotap_header wr_ihdr; 115 uint64_t wr_tsft; 116 uint8_t wr_flags; 117 uint8_t wr_rate; 118 uint16_t wr_chan_freq; 119 uint16_t wr_chan_flags; 120 int8_t wr_dbm_antsignal; 121 int8_t wr_dbm_antnoise; 122 } __packed __aligned(8); 123 #define LKPI_RTAP_RX_FLAGS_PRESENT \ 124 ((1 << IEEE80211_RADIOTAP_TSFT) | \ 125 (1 << IEEE80211_RADIOTAP_FLAGS) | \ 126 (1 << IEEE80211_RADIOTAP_RATE) | \ 127 (1 << IEEE80211_RADIOTAP_CHANNEL) | \ 128 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) | \ 129 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE)) 130 131 struct lkpi_hw; 132 133 struct lkpi_txq { 134 TAILQ_ENTRY(lkpi_txq) txq_entry; 135 136 struct mtx ltxq_mtx; 137 bool seen_dequeue; 138 bool stopped; 139 uint32_t txq_generation; 140 struct sk_buff_head skbq; 141 142 /* Must be last! */ 143 struct ieee80211_txq txq __aligned(CACHE_LINE_SIZE); 144 }; 145 #define TXQ_TO_LTXQ(_txq) container_of(_txq, struct lkpi_txq, txq) 146 147 148 struct lkpi_sta { 149 struct list_head lsta_list; 150 struct ieee80211_node *ni; 151 struct ieee80211_hw *hw; /* back pointer f. locking. */ 152 153 /* Deferred TX path. */ 154 /* Eventually we might want to migrate this into net80211 entirely. */ 155 /* XXX-BZ can we use sta->txq[] instead directly? */ 156 struct task txq_task; 157 struct mbufq txq; 158 struct mtx txq_mtx; 159 160 struct ieee80211_key_conf *kc[IEEE80211_WEP_NKID]; 161 enum ieee80211_sta_state state; 162 bool txq_ready; /* Can we run the taskq? */ 163 bool added_to_drv; /* Driver knows; i.e. we called ...(). */ 164 bool in_mgd; /* XXX-BZ should this be per-vif? */ 165 166 /* Must be last! */ 167 struct ieee80211_sta sta __aligned(CACHE_LINE_SIZE); 168 }; 169 #define STA_TO_LSTA(_sta) container_of(_sta, struct lkpi_sta, sta) 170 #define LSTA_TO_STA(_lsta) (&(_lsta)->sta) 171 172 /* Either protected by wiphy lock or rcu for the list. */ 173 struct lkpi_vif { 174 TAILQ_ENTRY(lkpi_vif) lvif_entry; 175 struct ieee80211vap iv_vap; 176 eventhandler_tag lvif_ifllevent; 177 178 struct sysctl_ctx_list sysctl_ctx; 179 180 struct mtx mtx; 181 struct wireless_dev wdev; 182 183 /* Other local stuff. */ 184 int (*iv_newstate)(struct ieee80211vap *, 185 enum ieee80211_state, int); 186 struct ieee80211_node * (*iv_update_bss)(struct ieee80211vap *, 187 struct ieee80211_node *); 188 struct list_head lsta_list; 189 190 struct lkpi_sta *lvif_bss; 191 192 int ic_unlocked; /* Count of ic unlocks pending (*mo_set_key) */ 193 int nt_unlocked; /* Count of nt unlocks pending (*mo_set_key) */ 194 bool lvif_bss_synched; 195 bool added_to_drv; /* Driver knows; i.e. we called add_interface(). */ 196 197 bool hw_queue_stopped[IEEE80211_NUM_ACS]; 198 199 /* Must be last! */ 200 struct ieee80211_vif vif __aligned(CACHE_LINE_SIZE); 201 }; 202 #define VAP_TO_LVIF(_vap) container_of(_vap, struct lkpi_vif, iv_vap) 203 #define LVIF_TO_VAP(_lvif) (&(_lvif)->iv_vap) 204 #define VIF_TO_LVIF(_vif) container_of(_vif, struct lkpi_vif, vif) 205 #define LVIF_TO_VIF(_lvif) (&(_lvif)->vif) 206 207 208 struct lkpi_hw { /* name it mac80211_sc? */ 209 const struct ieee80211_ops *ops; 210 struct ieee80211_scan_request *hw_req; 211 struct workqueue_struct *workq; 212 213 /* FreeBSD specific compat. */ 214 /* Linux device is in hw.wiphy->dev after SET_IEEE80211_DEV(). */ 215 struct ieee80211com *ic; 216 struct lkpi_radiotap_tx_hdr rtap_tx; 217 struct lkpi_radiotap_rx_hdr rtap_rx; 218 219 TAILQ_HEAD(, lkpi_vif) lvif_head; 220 struct sx lvif_sx; 221 222 struct list_head lchanctx_list; 223 224 struct mtx txq_mtx; 225 uint32_t txq_generation[IEEE80211_NUM_ACS]; 226 TAILQ_HEAD(, lkpi_txq) scheduled_txqs[IEEE80211_NUM_ACS]; 227 228 /* Deferred RX path. */ 229 struct task rxq_task; 230 struct mbufq rxq; 231 struct mtx rxq_mtx; 232 233 /* Scan functions we overload to handle depending on scan mode. */ 234 void (*ic_scan_curchan)(struct ieee80211_scan_state *, 235 unsigned long); 236 void (*ic_scan_mindwell)(struct ieee80211_scan_state *); 237 238 /* Node functions we overload to sync state. */ 239 struct ieee80211_node * (*ic_node_alloc)(struct ieee80211vap *, 240 const uint8_t [IEEE80211_ADDR_LEN]); 241 int (*ic_node_init)(struct ieee80211_node *); 242 void (*ic_node_cleanup)(struct ieee80211_node *); 243 void (*ic_node_free)(struct ieee80211_node *); 244 245 /* HT and later functions. */ 246 int (*ic_recv_action)(struct ieee80211_node *, 247 const struct ieee80211_frame *, 248 const uint8_t *, const uint8_t *); 249 int (*ic_send_action)(struct ieee80211_node *, 250 int, int, void *); 251 int (*ic_ampdu_enable)(struct ieee80211_node *, 252 struct ieee80211_tx_ampdu *); 253 int (*ic_addba_request)(struct ieee80211_node *, 254 struct ieee80211_tx_ampdu *, int, int, int); 255 int (*ic_addba_response)(struct ieee80211_node *, 256 struct ieee80211_tx_ampdu *, int, int, int); 257 void (*ic_addba_stop)(struct ieee80211_node *, 258 struct ieee80211_tx_ampdu *); 259 void (*ic_addba_response_timeout)(struct ieee80211_node *, 260 struct ieee80211_tx_ampdu *); 261 void (*ic_bar_response)(struct ieee80211_node *, 262 struct ieee80211_tx_ampdu *, int); 263 int (*ic_ampdu_rx_start)(struct ieee80211_node *, 264 struct ieee80211_rx_ampdu *, int, int, int); 265 void (*ic_ampdu_rx_stop)(struct ieee80211_node *, 266 struct ieee80211_rx_ampdu *); 267 268 #define LKPI_MAC80211_DRV_STARTED 0x00000001 269 uint32_t sc_flags; 270 #define LKPI_LHW_SCAN_RUNNING 0x00000001 271 #define LKPI_LHW_SCAN_HW 0x00000002 272 uint32_t scan_flags; 273 struct mtx scan_mtx; 274 275 int supbands; /* Number of supported bands. */ 276 int max_rates; /* Maximum number of bitrates supported in any channel. */ 277 int scan_ie_len; /* Length of common per-band scan IEs. */ 278 279 bool update_mc; 280 bool update_wme; 281 bool rxq_stopped; 282 283 /* Must be last! */ 284 struct ieee80211_hw hw __aligned(CACHE_LINE_SIZE); 285 }; 286 #define LHW_TO_HW(_lhw) (&(_lhw)->hw) 287 #define HW_TO_LHW(_hw) container_of(_hw, struct lkpi_hw, hw) 288 289 struct lkpi_chanctx { 290 struct list_head entry; 291 292 bool added_to_drv; /* Managed by MO */ 293 294 struct ieee80211_chanctx_conf chanctx_conf __aligned(CACHE_LINE_SIZE); 295 }; 296 #define LCHANCTX_TO_CHANCTX_CONF(_lchanctx) \ 297 (&(_lchanctx)->chanctx_conf) 298 #define CHANCTX_CONF_TO_LCHANCTX(_conf) \ 299 container_of(_conf, struct lkpi_chanctx, chanctx_conf) 300 301 struct lkpi_wiphy { 302 const struct cfg80211_ops *ops; 303 304 struct work_struct wwk; 305 struct list_head wwk_list; 306 struct mtx wwk_mtx; 307 308 /* Must be last! */ 309 struct wiphy wiphy __aligned(CACHE_LINE_SIZE); 310 }; 311 #define WIPHY_TO_LWIPHY(_wiphy) container_of(_wiphy, struct lkpi_wiphy, wiphy) 312 #define LWIPHY_TO_WIPHY(_lwiphy) (&(_lwiphy)->wiphy) 313 314 #define LKPI_80211_LWIPHY_WORK_LOCK_INIT(_lwiphy) \ 315 mtx_init(&(_lwiphy)->wwk_mtx, "lwiphy-work", NULL, MTX_DEF); 316 #define LKPI_80211_LWIPHY_WORK_LOCK_DESTROY(_lwiphy) \ 317 mtx_destroy(&(_lwiphy)->wwk_mtx) 318 #define LKPI_80211_LWIPHY_WORK_LOCK(_lwiphy) \ 319 mtx_lock(&(_lwiphy)->wwk_mtx) 320 #define LKPI_80211_LWIPHY_WORK_UNLOCK(_lwiphy) \ 321 mtx_unlock(&(_lwiphy)->wwk_mtx) 322 #define LKPI_80211_LWIPHY_WORK_LOCK_ASSERT(_lwiphy) \ 323 mtx_assert(&(_lwiphy)->wwk_mtx, MA_OWNED) 324 #define LKPI_80211_LWIPHY_WORK_UNLOCK_ASSERT(_lwiphy) \ 325 mtx_assert(&(_lwiphy)->wwk_mtx, MA_NOTOWNED) 326 327 #define LKPI_80211_LHW_SCAN_LOCK_INIT(_lhw) \ 328 mtx_init(&(_lhw)->scan_mtx, "lhw-scan", NULL, MTX_DEF | MTX_RECURSE); 329 #define LKPI_80211_LHW_SCAN_LOCK_DESTROY(_lhw) \ 330 mtx_destroy(&(_lhw)->scan_mtx); 331 #define LKPI_80211_LHW_SCAN_LOCK(_lhw) \ 332 mtx_lock(&(_lhw)->scan_mtx) 333 #define LKPI_80211_LHW_SCAN_UNLOCK(_lhw) \ 334 mtx_unlock(&(_lhw)->scan_mtx) 335 #define LKPI_80211_LHW_SCAN_LOCK_ASSERT(_lhw) \ 336 mtx_assert(&(_lhw)->scan_mtx, MA_OWNED) 337 #define LKPI_80211_LHW_SCAN_UNLOCK_ASSERT(_lhw) \ 338 mtx_assert(&(_lhw)->scan_mtx, MA_NOTOWNED) 339 340 #define LKPI_80211_LHW_TXQ_LOCK_INIT(_lhw) \ 341 mtx_init(&(_lhw)->txq_mtx, "lhw-txq", NULL, MTX_DEF | MTX_RECURSE); 342 #define LKPI_80211_LHW_TXQ_LOCK_DESTROY(_lhw) \ 343 mtx_destroy(&(_lhw)->txq_mtx); 344 #define LKPI_80211_LHW_TXQ_LOCK(_lhw) \ 345 mtx_lock(&(_lhw)->txq_mtx) 346 #define LKPI_80211_LHW_TXQ_UNLOCK(_lhw) \ 347 mtx_unlock(&(_lhw)->txq_mtx) 348 #define LKPI_80211_LHW_TXQ_LOCK_ASSERT(_lhw) \ 349 mtx_assert(&(_lhw)->txq_mtx, MA_OWNED) 350 #define LKPI_80211_LHW_TXQ_UNLOCK_ASSERT(_lhw) \ 351 mtx_assert(&(_lhw)->txq_mtx, MA_NOTOWNED) 352 353 #define LKPI_80211_LHW_RXQ_LOCK_INIT(_lhw) \ 354 mtx_init(&(_lhw)->rxq_mtx, "lhw-rxq", NULL, MTX_DEF | MTX_RECURSE); 355 #define LKPI_80211_LHW_RXQ_LOCK_DESTROY(_lhw) \ 356 mtx_destroy(&(_lhw)->rxq_mtx); 357 #define LKPI_80211_LHW_RXQ_LOCK(_lhw) \ 358 mtx_lock(&(_lhw)->rxq_mtx) 359 #define LKPI_80211_LHW_RXQ_UNLOCK(_lhw) \ 360 mtx_unlock(&(_lhw)->rxq_mtx) 361 #define LKPI_80211_LHW_RXQ_LOCK_ASSERT(_lhw) \ 362 mtx_assert(&(_lhw)->rxq_mtx, MA_OWNED) 363 #define LKPI_80211_LHW_RXQ_UNLOCK_ASSERT(_lhw) \ 364 mtx_assert(&(_lhw)->rxq_mtx, MA_NOTOWNED) 365 366 #define LKPI_80211_LHW_LVIF_LOCK(_lhw) sx_xlock(&(_lhw)->lvif_sx) 367 #define LKPI_80211_LHW_LVIF_UNLOCK(_lhw) sx_xunlock(&(_lhw)->lvif_sx) 368 369 #define LKPI_80211_LVIF_LOCK(_lvif) mtx_lock(&(_lvif)->mtx) 370 #define LKPI_80211_LVIF_UNLOCK(_lvif) mtx_unlock(&(_lvif)->mtx) 371 372 #define LKPI_80211_LSTA_TXQ_LOCK_INIT(_lsta) \ 373 mtx_init(&(_lsta)->txq_mtx, "lsta-txq", NULL, MTX_DEF); 374 #define LKPI_80211_LSTA_TXQ_LOCK_DESTROY(_lsta) \ 375 mtx_destroy(&(_lsta)->txq_mtx); 376 #define LKPI_80211_LSTA_TXQ_LOCK(_lsta) \ 377 mtx_lock(&(_lsta)->txq_mtx) 378 #define LKPI_80211_LSTA_TXQ_UNLOCK(_lsta) \ 379 mtx_unlock(&(_lsta)->txq_mtx) 380 #define LKPI_80211_LSTA_TXQ_LOCK_ASSERT(_lsta) \ 381 mtx_assert(&(_lsta)->txq_mtx, MA_OWNED) 382 #define LKPI_80211_LSTA_TXQ_UNLOCK_ASSERT(_lsta) \ 383 mtx_assert(&(_lsta)->txq_mtx, MA_NOTOWNED) 384 385 #define LKPI_80211_LTXQ_LOCK_INIT(_ltxq) \ 386 mtx_init(&(_ltxq)->ltxq_mtx, "ltxq", NULL, MTX_DEF); 387 #define LKPI_80211_LTXQ_LOCK_DESTROY(_ltxq) \ 388 mtx_destroy(&(_ltxq)->ltxq_mtx); 389 #define LKPI_80211_LTXQ_LOCK(_ltxq) \ 390 mtx_lock(&(_ltxq)->ltxq_mtx) 391 #define LKPI_80211_LTXQ_UNLOCK(_ltxq) \ 392 mtx_unlock(&(_ltxq)->ltxq_mtx) 393 #define LKPI_80211_LTXQ_LOCK_ASSERT(_ltxq) \ 394 mtx_assert(&(_ltxq)->ltxq_mtx, MA_OWNED) 395 #define LKPI_80211_LTXQ_UNLOCK_ASSERT(_ltxq) \ 396 mtx_assert(&(_ltxq)->ltxq_mtx, MA_NOTOWNED) 397 398 int lkpi_80211_mo_start(struct ieee80211_hw *); 399 void lkpi_80211_mo_stop(struct ieee80211_hw *, bool); 400 int lkpi_80211_mo_get_antenna(struct ieee80211_hw *, u32 *, u32 *); 401 int lkpi_80211_mo_set_frag_threshold(struct ieee80211_hw *, uint32_t); 402 int lkpi_80211_mo_set_rts_threshold(struct ieee80211_hw *, uint32_t); 403 int lkpi_80211_mo_add_interface(struct ieee80211_hw *, struct ieee80211_vif *); 404 void lkpi_80211_mo_remove_interface(struct ieee80211_hw *, struct ieee80211_vif *); 405 int lkpi_80211_mo_hw_scan(struct ieee80211_hw *, struct ieee80211_vif *, 406 struct ieee80211_scan_request *); 407 void lkpi_80211_mo_cancel_hw_scan(struct ieee80211_hw *, struct ieee80211_vif *); 408 void lkpi_80211_mo_sw_scan_complete(struct ieee80211_hw *, struct ieee80211_vif *); 409 void lkpi_80211_mo_sw_scan_start(struct ieee80211_hw *, struct ieee80211_vif *, 410 const u8 *); 411 u64 lkpi_80211_mo_prepare_multicast(struct ieee80211_hw *, 412 struct netdev_hw_addr_list *); 413 void lkpi_80211_mo_configure_filter(struct ieee80211_hw *, unsigned int, 414 unsigned int *, u64); 415 int lkpi_80211_mo_sta_state(struct ieee80211_hw *, struct ieee80211_vif *, 416 struct lkpi_sta *, enum ieee80211_sta_state); 417 int lkpi_80211_mo_config(struct ieee80211_hw *, uint32_t); 418 int lkpi_80211_mo_assign_vif_chanctx(struct ieee80211_hw *, struct ieee80211_vif *, 419 struct ieee80211_bss_conf *, struct ieee80211_chanctx_conf *); 420 void lkpi_80211_mo_unassign_vif_chanctx(struct ieee80211_hw *, struct ieee80211_vif *, 421 struct ieee80211_bss_conf *, struct ieee80211_chanctx_conf *); 422 int lkpi_80211_mo_add_chanctx(struct ieee80211_hw *, struct ieee80211_chanctx_conf *); 423 void lkpi_80211_mo_change_chanctx(struct ieee80211_hw *, 424 struct ieee80211_chanctx_conf *, uint32_t); 425 void lkpi_80211_mo_remove_chanctx(struct ieee80211_hw *, 426 struct ieee80211_chanctx_conf *); 427 void lkpi_80211_mo_bss_info_changed(struct ieee80211_hw *, struct ieee80211_vif *, 428 struct ieee80211_bss_conf *, uint64_t); 429 int lkpi_80211_mo_conf_tx(struct ieee80211_hw *, struct ieee80211_vif *, 430 uint32_t, uint16_t, const struct ieee80211_tx_queue_params *); 431 void lkpi_80211_mo_flush(struct ieee80211_hw *, struct ieee80211_vif *, 432 uint32_t, bool); 433 void lkpi_80211_mo_mgd_prepare_tx(struct ieee80211_hw *, struct ieee80211_vif *, 434 struct ieee80211_prep_tx_info *); 435 void lkpi_80211_mo_mgd_complete_tx(struct ieee80211_hw *, struct ieee80211_vif *, 436 struct ieee80211_prep_tx_info *); 437 void lkpi_80211_mo_tx(struct ieee80211_hw *, struct ieee80211_tx_control *, 438 struct sk_buff *); 439 void lkpi_80211_mo_wake_tx_queue(struct ieee80211_hw *, struct ieee80211_txq *); 440 void lkpi_80211_mo_sync_rx_queues(struct ieee80211_hw *); 441 void lkpi_80211_mo_sta_pre_rcu_remove(struct ieee80211_hw *, 442 struct ieee80211_vif *, struct ieee80211_sta *); 443 int lkpi_80211_mo_set_key(struct ieee80211_hw *, enum set_key_cmd, 444 struct ieee80211_vif *, struct ieee80211_sta *, 445 struct ieee80211_key_conf *); 446 int lkpi_80211_mo_ampdu_action(struct ieee80211_hw *, struct ieee80211_vif *, 447 struct ieee80211_ampdu_params *); 448 int lkpi_80211_mo_sta_statistics(struct ieee80211_hw *, struct ieee80211_vif *, 449 struct ieee80211_sta *, struct station_info *); 450 451 #endif /* _LKPI_SRC_LINUX_80211_H */ 452