1 /*- 2 * Copyright (c) 2020-2026 The FreeBSD Foundation 3 * Copyright (c) 2020-2025 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 #include <linux/skbuff.h> 48 #include <net/mac80211.h> 49 50 #if defined(IEEE80211_DEBUG) && !defined(LINUXKPI_DEBUG_80211) 51 #define LINUXKPI_DEBUG_80211 52 #endif 53 54 /* #define LINUXKPI_DEBUG_80211 */ 55 56 #ifndef D80211_TODO 57 #define D80211_TODO 0x00000001 58 #endif 59 #ifndef D80211_IMPROVE 60 #define D80211_IMPROVE 0x00000002 61 #endif 62 #define D80211_IMPROVE_TXQ 0x00000004 63 #define D80211_CHANDEF 0x00000008 64 #define D80211_TRACE 0x00000010 65 #define D80211_TRACEOK 0x00000020 66 #define D80211_SCAN 0x00000040 67 #define D80211_SCAN_BEACON 0x00000080 68 #define D80211_TRACE_TX 0x00000100 69 #define D80211_TRACE_TX_DUMP 0x00000200 70 #define D80211_TRACE_RX 0x00001000 71 #define D80211_TRACE_RX_DUMP 0x00002000 72 #define D80211_TRACE_RX_BEACONS 0x00004000 73 #define D80211_TRACEX (D80211_TRACE_TX|D80211_TRACE_RX) 74 #define D80211_TRACEX_DUMP (D80211_TRACE_TX_DUMP|D80211_TRACE_RX_DUMP) 75 #define D80211_TRACE_STA 0x00010000 76 #define D80211_TRACE_HW_CRYPTO 0x00020000 77 #define D80211_TRACE_RATES 0x00040000 78 #define D80211_TRACE_MO 0x00100000 79 #define D80211_TRACE_MODE 0x0f000000 80 #define D80211_TRACE_MODE_HT 0x01000000 81 #define D80211_TRACE_MODE_VHT 0x02000000 82 #define D80211_TRACE_MODE_HE 0x04000000 83 #define D80211_TRACE_MODE_EHT 0x08000000 84 85 #ifdef LINUXKPI_DEBUG_80211 86 #define TRACE_SCAN(ic, fmt, ...) \ 87 if (linuxkpi_debug_80211 & D80211_SCAN) \ 88 printf("%s:%d: %s SCAN " fmt "\n", \ 89 __func__, __LINE__, ic->ic_name, ##__VA_ARGS__) 90 #define TRACE_SCAN_BEACON(ic, fmt, ...) \ 91 if (linuxkpi_debug_80211 & D80211_SCAN_BEACON) \ 92 printf("%s:%d: %s SCAN " fmt "\n", \ 93 __func__, __LINE__, ic->ic_name, ##__VA_ARGS__) 94 #define TRACE_RATES(fmt, ...) \ 95 if (linuxkpi_debug_80211 & D80211_TRACE_RATES) \ 96 printf("%s:%d: LKPI80211 RATES " fmt "\n", \ 97 __func__, __LINE__, ##__VA_ARGS__); 98 99 #else 100 #define TRACE_SCAN(...) do {} while (0) 101 #define TRACE_SCAN_BEACON(...) do {} while (0) 102 #define TRACE_RATES(...) do {} while(0) 103 #endif 104 105 #define IMPROVE_TXQ(...) \ 106 if (linuxkpi_debug_80211 & D80211_IMPROVE_TXQ) \ 107 printf("%s:%d: XXX LKPI80211 IMPROVE_TXQ\n", __func__, __LINE__) 108 109 #define IMPROVE_HT(fmt, ...) \ 110 if (linuxkpi_debug_80211 & D80211_TRACE_MODE_HT) \ 111 printf("%s:%d: XXX LKPI80211 IMPROVE_HT " fmt "\n", \ 112 __func__, __LINE__, ##__VA_ARGS__); 113 114 #define MTAG_ABI_LKPI80211 1707696513 /* LinuxKPI 802.11 KBI */ 115 116 #ifdef LKPI_80211_USE_MTAG 117 /* 118 * Deferred RX path. 119 * We need to pass *ni along (and possibly more in the future so 120 * we use a struct right from the start. 121 */ 122 #define LKPI80211_TAG_RXNI 0 /* deferred RX path */ 123 struct lkpi_80211_tag_rxni { 124 struct ieee80211_node *ni; /* MUST hold a reference to it. */ 125 }; 126 #endif 127 128 struct lkpi_radiotap_tx_hdr { 129 struct ieee80211_radiotap_header wt_ihdr; 130 uint8_t wt_flags; 131 uint8_t wt_rate; 132 uint16_t wt_chan_freq; 133 uint16_t wt_chan_flags; 134 } __packed; 135 #define LKPI_RTAP_TX_FLAGS_PRESENT \ 136 ((1 << IEEE80211_RADIOTAP_FLAGS) | \ 137 (1 << IEEE80211_RADIOTAP_RATE) | \ 138 (1 << IEEE80211_RADIOTAP_CHANNEL)) 139 140 struct lkpi_radiotap_rx_hdr { 141 struct ieee80211_radiotap_header wr_ihdr; 142 uint64_t wr_tsft; 143 uint8_t wr_flags; 144 uint8_t wr_rate; 145 uint16_t wr_chan_freq; 146 uint16_t wr_chan_flags; 147 int8_t wr_dbm_antsignal; 148 int8_t wr_dbm_antnoise; 149 } __packed __aligned(8); 150 #define LKPI_RTAP_RX_FLAGS_PRESENT \ 151 ((1 << IEEE80211_RADIOTAP_TSFT) | \ 152 (1 << IEEE80211_RADIOTAP_FLAGS) | \ 153 (1 << IEEE80211_RADIOTAP_RATE) | \ 154 (1 << IEEE80211_RADIOTAP_CHANNEL) | \ 155 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) | \ 156 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE)) 157 158 struct lkpi_hw; 159 160 enum lkpi_txq_flags { 161 LKPI_TXQ_SEEN_DEQUEUE = 0x01, 162 LKPI_TXQ_STOPPED = 0x02, 163 LKPI_TXQ_STOPPED_BA = 0x04, 164 }; 165 #define LKPI_TXQ_FLAGS_BITS \ 166 "\010\1SEEN_DEQUEUE\2STOPPED\3STOPPED_BA" 167 168 struct lkpi_txq { 169 TAILQ_ENTRY(lkpi_txq) txq_entry; 170 171 struct mtx ltxq_mtx; 172 enum lkpi_txq_flags flags; 173 174 uint32_t txq_generation; 175 struct sk_buff_head skbq; 176 uint64_t frms_enqueued; 177 uint64_t frms_dequeued; 178 uint64_t frms_tx; 179 180 /* Must be last! */ 181 struct ieee80211_txq txq __aligned(CACHE_LINE_SIZE); 182 }; 183 #define TXQ_TO_LTXQ(_txq) container_of(_txq, struct lkpi_txq, txq) 184 185 186 struct lkpi_sta { 187 struct list_head lsta_list; 188 struct ieee80211_node *ni; 189 struct ieee80211_hw *hw; /* back pointer f. locking. */ 190 191 /* Deferred TX path. */ 192 /* Eventually we might want to migrate this into net80211 entirely. */ 193 /* XXX-BZ can we use sta->txq[] instead directly? */ 194 struct task txq_task; 195 struct mbufq txq; 196 struct mtx txq_mtx; 197 198 struct ieee80211_key_conf *kc[IEEE80211_WEP_NKID]; 199 enum ieee80211_sta_state state; 200 bool txq_ready; /* Can we run the taskq? */ 201 bool added_to_drv; /* Driver knows; i.e. we called ...(). */ 202 bool in_mgd; /* XXX-BZ should this be per-vif? */ 203 204 struct station_info sinfo; /* statistics */ 205 uint64_t frms_tx; /* (*tx) */ 206 207 /* Must be last! */ 208 struct ieee80211_sta sta __aligned(CACHE_LINE_SIZE); 209 }; 210 #define STA_TO_LSTA(_sta) container_of(_sta, struct lkpi_sta, sta) 211 #define LSTA_TO_STA(_lsta) (&(_lsta)->sta) 212 213 /* Either protected by wiphy lock or rcu for the list. */ 214 struct lkpi_vif { 215 TAILQ_ENTRY(lkpi_vif) lvif_entry; 216 struct ieee80211vap iv_vap; 217 eventhandler_tag lvif_ifllevent; 218 219 struct sysctl_ctx_list sysctl_ctx; 220 221 struct mtx mtx; 222 struct wireless_dev wdev; 223 struct cfg80211_bitrate_mask br_mask; 224 225 /* Other local stuff. */ 226 int (*iv_newstate)(struct ieee80211vap *, 227 enum ieee80211_state, int); 228 struct ieee80211_node * (*iv_update_bss)(struct ieee80211vap *, 229 struct ieee80211_node *); 230 void (*iv_recv_mgmt)(struct ieee80211_node *, 231 struct mbuf *, int, 232 const struct ieee80211_rx_stats *, 233 int, int); 234 struct task sw_scan_task; 235 236 struct list_head lsta_list; 237 238 struct lkpi_sta *lvif_bss; 239 240 struct ieee80211_node *key_update_iv_bss; 241 int ic_unlocked; /* Count of ic unlocks pending (*mo_set_key) */ 242 int nt_unlocked; /* Count of nt unlocks pending (*mo_set_key) */ 243 int beacons; /* # of beacons since assoc */ 244 bool lvif_bss_synched; 245 bool added_to_drv; /* Driver knows; i.e. we called add_interface(). */ 246 247 bool hw_queue_stopped[IEEE80211_NUM_ACS]; 248 249 /* Must be last! */ 250 struct ieee80211_vif vif __aligned(CACHE_LINE_SIZE); 251 }; 252 #define VAP_TO_LVIF(_vap) container_of(_vap, struct lkpi_vif, iv_vap) 253 #define LVIF_TO_VAP(_lvif) (&(_lvif)->iv_vap) 254 #define VIF_TO_LVIF(_vif) container_of(_vif, struct lkpi_vif, vif) 255 #define LVIF_TO_VIF(_lvif) (&(_lvif)->vif) 256 257 258 struct lkpi_hw { /* name it mac80211_sc? */ 259 const struct ieee80211_ops *ops; 260 struct ieee80211_scan_request *hw_req; 261 struct workqueue_struct *workq; 262 263 /* FreeBSD specific compat. */ 264 /* Linux device is in hw.wiphy->dev after SET_IEEE80211_DEV(). */ 265 struct ieee80211com *ic; 266 struct lkpi_radiotap_tx_hdr rtap_tx; 267 struct lkpi_radiotap_rx_hdr rtap_rx; 268 269 TAILQ_HEAD(, lkpi_vif) lvif_head; 270 struct sx lvif_sx; 271 272 struct list_head lchanctx_list; 273 struct list_head lchanctx_list_reserved; 274 struct netdev_hw_addr_list mc_list; 275 unsigned int mc_flags; 276 struct sx mc_sx; 277 278 struct cfg80211_chan_def dflt_chandef; 279 struct cfg80211_chan_def scan_chandef; 280 281 struct mtx txq_mtx; 282 uint32_t txq_generation[IEEE80211_NUM_ACS]; 283 spinlock_t txq_scheduled_lock[IEEE80211_NUM_ACS]; 284 TAILQ_HEAD(, lkpi_txq) txq_scheduled[IEEE80211_NUM_ACS]; 285 spinlock_t txq_lock; 286 287 /* Deferred RX path. */ 288 struct task rxq_task; 289 struct mbufq rxq; 290 struct mtx rxq_mtx; 291 292 /* Scan functions we overload to handle depending on scan mode. */ 293 void (*ic_scan_curchan)(struct ieee80211_scan_state *, 294 unsigned long); 295 void (*ic_scan_mindwell)(struct ieee80211_scan_state *); 296 297 /* Node functions we overload to sync state. */ 298 struct ieee80211_node * (*ic_node_alloc)(struct ieee80211vap *, 299 const uint8_t [IEEE80211_ADDR_LEN]); 300 int (*ic_node_init)(struct ieee80211_node *); 301 void (*ic_node_cleanup)(struct ieee80211_node *); 302 void (*ic_node_free)(struct ieee80211_node *); 303 304 /* HT and later functions. */ 305 int (*ic_recv_action)(struct ieee80211_node *, 306 const struct ieee80211_frame *, 307 const uint8_t *, const uint8_t *); 308 int (*ic_send_action)(struct ieee80211_node *, 309 int, int, void *); 310 int (*ic_ampdu_enable)(struct ieee80211_node *, 311 struct ieee80211_tx_ampdu *); 312 int (*ic_addba_request)(struct ieee80211_node *, 313 struct ieee80211_tx_ampdu *, int, int, int); 314 int (*ic_addba_response)(struct ieee80211_node *, 315 struct ieee80211_tx_ampdu *, int, int, int); 316 void (*ic_addba_stop)(struct ieee80211_node *, 317 struct ieee80211_tx_ampdu *); 318 void (*ic_addba_response_timeout)(struct ieee80211_node *, 319 struct ieee80211_tx_ampdu *); 320 void (*ic_bar_response)(struct ieee80211_node *, 321 struct ieee80211_tx_ampdu *, int); 322 int (*ic_ampdu_rx_start)(struct ieee80211_node *, 323 struct ieee80211_rx_ampdu *, int, int, int); 324 void (*ic_ampdu_rx_stop)(struct ieee80211_node *, 325 struct ieee80211_rx_ampdu *); 326 327 #define LKPI_MAC80211_DRV_STARTED 0x00000001 328 uint32_t sc_flags; 329 #define LKPI_LHW_SCAN_RUNNING 0x00000001 330 #define LKPI_LHW_SCAN_HW 0x00000002 331 uint32_t scan_flags; 332 struct mtx scan_mtx; 333 334 int supbands; /* Number of supported bands. */ 335 int max_rates; /* Maximum number of bitrates supported in any channel. */ 336 int scan_ie_len; /* Length of common per-band scan IEs. */ 337 338 bool mc_all_multi; 339 bool update_wme; 340 bool rxq_stopped; 341 bool emulate_chanctx; 342 343 /* Must be last! */ 344 struct ieee80211_hw hw __aligned(CACHE_LINE_SIZE); 345 }; 346 #define LHW_TO_HW(_lhw) (&(_lhw)->hw) 347 #define HW_TO_LHW(_hw) container_of(_hw, struct lkpi_hw, hw) 348 349 #define LKPI_LHW_SCAN_BITS \ 350 "\010\1RUNING\2HW" 351 352 struct lkpi_chanctx { 353 struct list_head entry; 354 355 bool added_to_drv; /* Managed by MO */ 356 struct lkpi_vif *lvif; /* Backpointer. */ 357 358 struct ieee80211_chanctx_conf chanctx_conf __aligned(CACHE_LINE_SIZE); 359 }; 360 #define LCHANCTX_TO_CHANCTX_CONF(_lchanctx) \ 361 (&(_lchanctx)->chanctx_conf) 362 #define CHANCTX_CONF_TO_LCHANCTX(_conf) \ 363 container_of(_conf, struct lkpi_chanctx, chanctx_conf) 364 365 struct lkpi_wiphy { 366 const struct cfg80211_ops *ops; 367 368 struct work_struct wwk; 369 struct list_head wwk_list; 370 struct mtx wwk_mtx; 371 372 /* Must be last! */ 373 struct wiphy wiphy __aligned(CACHE_LINE_SIZE); 374 }; 375 #define WIPHY_TO_LWIPHY(_wiphy) container_of(_wiphy, struct lkpi_wiphy, wiphy) 376 #define LWIPHY_TO_WIPHY(_lwiphy) (&(_lwiphy)->wiphy) 377 378 #define LKPI_80211_LWIPHY_WORK_LOCK_INIT(_lwiphy) \ 379 mtx_init(&(_lwiphy)->wwk_mtx, "lwiphy-work", NULL, MTX_DEF); 380 #define LKPI_80211_LWIPHY_WORK_LOCK_DESTROY(_lwiphy) \ 381 mtx_destroy(&(_lwiphy)->wwk_mtx) 382 #define LKPI_80211_LWIPHY_WORK_LOCK(_lwiphy) \ 383 mtx_lock(&(_lwiphy)->wwk_mtx) 384 #define LKPI_80211_LWIPHY_WORK_UNLOCK(_lwiphy) \ 385 mtx_unlock(&(_lwiphy)->wwk_mtx) 386 #define LKPI_80211_LWIPHY_WORK_LOCK_ASSERT(_lwiphy) \ 387 mtx_assert(&(_lwiphy)->wwk_mtx, MA_OWNED) 388 #define LKPI_80211_LWIPHY_WORK_UNLOCK_ASSERT(_lwiphy) \ 389 mtx_assert(&(_lwiphy)->wwk_mtx, MA_NOTOWNED) 390 391 #define LKPI_80211_LHW_SCAN_LOCK_INIT(_lhw) \ 392 mtx_init(&(_lhw)->scan_mtx, "lhw-scan", NULL, MTX_DEF | MTX_RECURSE); 393 #define LKPI_80211_LHW_SCAN_LOCK_DESTROY(_lhw) \ 394 mtx_destroy(&(_lhw)->scan_mtx); 395 #define LKPI_80211_LHW_SCAN_LOCK(_lhw) \ 396 mtx_lock(&(_lhw)->scan_mtx) 397 #define LKPI_80211_LHW_SCAN_UNLOCK(_lhw) \ 398 mtx_unlock(&(_lhw)->scan_mtx) 399 #define LKPI_80211_LHW_SCAN_LOCK_ASSERT(_lhw) \ 400 mtx_assert(&(_lhw)->scan_mtx, MA_OWNED) 401 #define LKPI_80211_LHW_SCAN_UNLOCK_ASSERT(_lhw) \ 402 mtx_assert(&(_lhw)->scan_mtx, MA_NOTOWNED) 403 404 #define LKPI_80211_LHW_TXQ_LOCK_INIT(_lhw) \ 405 mtx_init(&(_lhw)->txq_mtx, "lhw-txq", NULL, MTX_DEF | MTX_RECURSE); 406 #define LKPI_80211_LHW_TXQ_LOCK_DESTROY(_lhw) \ 407 mtx_destroy(&(_lhw)->txq_mtx); 408 #define LKPI_80211_LHW_TXQ_LOCK(_lhw) \ 409 mtx_lock(&(_lhw)->txq_mtx) 410 #define LKPI_80211_LHW_TXQ_UNLOCK(_lhw) \ 411 mtx_unlock(&(_lhw)->txq_mtx) 412 #define LKPI_80211_LHW_TXQ_LOCK_ASSERT(_lhw) \ 413 mtx_assert(&(_lhw)->txq_mtx, MA_OWNED) 414 #define LKPI_80211_LHW_TXQ_UNLOCK_ASSERT(_lhw) \ 415 mtx_assert(&(_lhw)->txq_mtx, MA_NOTOWNED) 416 417 #define LKPI_80211_LHW_RXQ_LOCK_INIT(_lhw) \ 418 mtx_init(&(_lhw)->rxq_mtx, "lhw-rxq", NULL, MTX_DEF | MTX_RECURSE); 419 #define LKPI_80211_LHW_RXQ_LOCK_DESTROY(_lhw) \ 420 mtx_destroy(&(_lhw)->rxq_mtx); 421 #define LKPI_80211_LHW_RXQ_LOCK(_lhw) \ 422 mtx_lock(&(_lhw)->rxq_mtx) 423 #define LKPI_80211_LHW_RXQ_UNLOCK(_lhw) \ 424 mtx_unlock(&(_lhw)->rxq_mtx) 425 #define LKPI_80211_LHW_RXQ_LOCK_ASSERT(_lhw) \ 426 mtx_assert(&(_lhw)->rxq_mtx, MA_OWNED) 427 #define LKPI_80211_LHW_RXQ_UNLOCK_ASSERT(_lhw) \ 428 mtx_assert(&(_lhw)->rxq_mtx, MA_NOTOWNED) 429 430 #define LKPI_80211_LHW_LVIF_LOCK(_lhw) sx_xlock(&(_lhw)->lvif_sx) 431 #define LKPI_80211_LHW_LVIF_UNLOCK(_lhw) sx_xunlock(&(_lhw)->lvif_sx) 432 433 #define LKPI_80211_LHW_MC_LOCK_INIT(_lhw) \ 434 sx_init_flags(&lhw->mc_sx, "lhw-mc", 0); 435 #define LKPI_80211_LHW_MC_LOCK_DESTROY(_lhw) \ 436 sx_destroy(&lhw->mc_sx); 437 #define LKPI_80211_LHW_MC_LOCK(_lhw) sx_xlock(&(_lhw)->mc_sx) 438 #define LKPI_80211_LHW_MC_UNLOCK(_lhw) sx_xunlock(&(_lhw)->mc_sx) 439 440 #define LKPI_80211_LVIF_LOCK(_lvif) mtx_lock(&(_lvif)->mtx) 441 #define LKPI_80211_LVIF_UNLOCK(_lvif) mtx_unlock(&(_lvif)->mtx) 442 443 #define LKPI_80211_LSTA_TXQ_LOCK_INIT(_lsta) \ 444 mtx_init(&(_lsta)->txq_mtx, "lsta-txq", NULL, MTX_DEF); 445 #define LKPI_80211_LSTA_TXQ_LOCK_DESTROY(_lsta) \ 446 mtx_destroy(&(_lsta)->txq_mtx); 447 #define LKPI_80211_LSTA_TXQ_LOCK(_lsta) \ 448 mtx_lock(&(_lsta)->txq_mtx) 449 #define LKPI_80211_LSTA_TXQ_UNLOCK(_lsta) \ 450 mtx_unlock(&(_lsta)->txq_mtx) 451 #define LKPI_80211_LSTA_TXQ_LOCK_ASSERT(_lsta) \ 452 mtx_assert(&(_lsta)->txq_mtx, MA_OWNED) 453 #define LKPI_80211_LSTA_TXQ_UNLOCK_ASSERT(_lsta) \ 454 mtx_assert(&(_lsta)->txq_mtx, MA_NOTOWNED) 455 456 #define LKPI_80211_LTXQ_LOCK_INIT(_ltxq) \ 457 mtx_init(&(_ltxq)->ltxq_mtx, "ltxq", NULL, MTX_DEF); 458 #define LKPI_80211_LTXQ_LOCK_DESTROY(_ltxq) \ 459 mtx_destroy(&(_ltxq)->ltxq_mtx); 460 #define LKPI_80211_LTXQ_LOCK(_ltxq) \ 461 mtx_lock(&(_ltxq)->ltxq_mtx) 462 #define LKPI_80211_LTXQ_UNLOCK(_ltxq) \ 463 mtx_unlock(&(_ltxq)->ltxq_mtx) 464 #define LKPI_80211_LTXQ_LOCK_ASSERT(_ltxq) \ 465 mtx_assert(&(_ltxq)->ltxq_mtx, MA_OWNED) 466 #define LKPI_80211_LTXQ_UNLOCK_ASSERT(_ltxq) \ 467 mtx_assert(&(_ltxq)->ltxq_mtx, MA_NOTOWNED) 468 469 int lkpi_80211_mo_start(struct ieee80211_hw *); 470 void lkpi_80211_mo_stop(struct ieee80211_hw *, bool); 471 int lkpi_80211_mo_get_antenna(struct ieee80211_hw *, u32 *, u32 *); 472 int lkpi_80211_mo_set_frag_threshold(struct ieee80211_hw *, uint32_t); 473 int lkpi_80211_mo_set_rts_threshold(struct ieee80211_hw *, uint32_t); 474 int lkpi_80211_mo_add_interface(struct ieee80211_hw *, struct ieee80211_vif *); 475 void lkpi_80211_mo_remove_interface(struct ieee80211_hw *, struct ieee80211_vif *); 476 int lkpi_80211_mo_hw_scan(struct ieee80211_hw *, struct ieee80211_vif *, 477 struct ieee80211_scan_request *); 478 void lkpi_80211_mo_cancel_hw_scan(struct ieee80211_hw *, struct ieee80211_vif *); 479 void lkpi_80211_mo_sw_scan_complete(struct ieee80211_hw *, struct ieee80211_vif *); 480 void lkpi_80211_mo_sw_scan_start(struct ieee80211_hw *, struct ieee80211_vif *, 481 const u8 *); 482 u64 lkpi_80211_mo_prepare_multicast(struct ieee80211_hw *, 483 struct netdev_hw_addr_list *); 484 void lkpi_80211_mo_configure_filter(struct ieee80211_hw *, unsigned int, 485 unsigned int *, u64); 486 int lkpi_80211_mo_sta_state(struct ieee80211_hw *, struct ieee80211_vif *, 487 struct lkpi_sta *, enum ieee80211_sta_state); 488 int lkpi_80211_mo_config(struct ieee80211_hw *, uint32_t); 489 int lkpi_80211_mo_assign_vif_chanctx(struct ieee80211_hw *, struct ieee80211_vif *, 490 struct ieee80211_bss_conf *, struct ieee80211_chanctx_conf *); 491 void lkpi_80211_mo_unassign_vif_chanctx(struct ieee80211_hw *, struct ieee80211_vif *, 492 struct ieee80211_bss_conf *, struct ieee80211_chanctx_conf *); 493 int lkpi_80211_mo_add_chanctx(struct ieee80211_hw *, struct ieee80211_chanctx_conf *); 494 void lkpi_80211_mo_change_chanctx(struct ieee80211_hw *, 495 struct ieee80211_chanctx_conf *, uint32_t); 496 void lkpi_80211_mo_remove_chanctx(struct ieee80211_hw *, 497 struct ieee80211_chanctx_conf *); 498 void lkpi_80211_mo_vif_cfg_changed(struct ieee80211_hw *, struct ieee80211_vif *, 499 uint64_t, bool); 500 void lkpi_80211_mo_link_info_changed(struct ieee80211_hw *, struct ieee80211_vif *, 501 struct ieee80211_bss_conf *, uint64_t, uint8_t, bool); 502 void lkpi_80211_mo_bss_info_changed(struct ieee80211_hw *, struct ieee80211_vif *, 503 struct ieee80211_bss_conf *, uint64_t); 504 int lkpi_80211_mo_conf_tx(struct ieee80211_hw *, struct ieee80211_vif *, 505 uint32_t, uint16_t, const struct ieee80211_tx_queue_params *); 506 void lkpi_80211_mo_flush(struct ieee80211_hw *, struct ieee80211_vif *, 507 uint32_t, bool); 508 void lkpi_80211_mo_mgd_prepare_tx(struct ieee80211_hw *, struct ieee80211_vif *, 509 struct ieee80211_prep_tx_info *); 510 void lkpi_80211_mo_mgd_complete_tx(struct ieee80211_hw *, struct ieee80211_vif *, 511 struct ieee80211_prep_tx_info *); 512 void lkpi_80211_mo_tx(struct ieee80211_hw *, struct ieee80211_tx_control *, 513 struct sk_buff *); 514 void lkpi_80211_mo_wake_tx_queue(struct ieee80211_hw *, struct ieee80211_txq *, 515 bool); 516 void lkpi_80211_mo_sync_rx_queues(struct ieee80211_hw *); 517 void lkpi_80211_mo_sta_pre_rcu_remove(struct ieee80211_hw *, 518 struct ieee80211_vif *, struct ieee80211_sta *); 519 void lkpi_80211_mo_link_sta_rc_update(struct ieee80211_hw *, 520 struct ieee80211_vif *, struct ieee80211_link_sta *, 521 enum ieee80211_rate_control_changed_flags); 522 int lkpi_80211_mo_set_bitrate_mask(struct ieee80211_hw *, 523 struct ieee80211_vif *, const struct cfg80211_bitrate_mask *); 524 int lkpi_80211_mo_set_key(struct ieee80211_hw *, enum set_key_cmd, 525 struct ieee80211_vif *, struct ieee80211_sta *, 526 struct ieee80211_key_conf *); 527 void lkpi_80211_mo_sta_set_decap_offload(struct ieee80211_hw *, 528 struct ieee80211_vif *, struct ieee80211_sta *, bool); 529 int lkpi_80211_mo_ampdu_action(struct ieee80211_hw *, struct ieee80211_vif *, 530 struct ieee80211_ampdu_params *); 531 int lkpi_80211_mo_sta_statistics(struct ieee80211_hw *, struct ieee80211_vif *, 532 struct ieee80211_sta *, struct station_info *); 533 int lkpi_80211_mo_suspend(struct ieee80211_hw *, struct cfg80211_wowlan *); 534 int lkpi_80211_mo_resume(struct ieee80211_hw *); 535 int lkpi_80211_mo_set_wakeup(struct ieee80211_hw *, bool); 536 int lkpi_80211_mo_set_rekey_data(struct ieee80211_hw *, 537 struct ieee80211_vif *, struct cfg80211_gtk_rekey_data *); 538 int lkpi_80211_mo_set_default_unicast_key(struct ieee80211_hw *, 539 struct ieee80211_vif *, int); 540 541 /* LinuxKPI 802.11 PM. */ 542 int lkpi_80211_suspend(struct ieee80211com *, pm_message_t); 543 int lkpi_80211_resume(struct ieee80211com *); 544 545 #endif /* _LKPI_SRC_LINUX_80211_H */ 546