1 /*- 2 * Copyright (c) 2020-2025 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 /* 43 * TODO: 44 * - lots :) 45 * - HW_CRYPTO: we need a "keystore" and an ordered list for suspend/resume. 46 */ 47 48 #include <sys/param.h> 49 #include <sys/types.h> 50 #include <sys/kernel.h> 51 #include <sys/errno.h> 52 #include <sys/malloc.h> 53 #include <sys/module.h> 54 #include <sys/mutex.h> 55 #include <sys/sbuf.h> 56 #include <sys/socket.h> 57 #include <sys/sysctl.h> 58 #include <sys/queue.h> 59 #include <sys/taskqueue.h> 60 #include <sys/libkern.h> 61 62 #include <net/if.h> 63 #include <net/if_var.h> 64 #include <net/if_media.h> 65 #include <net/ethernet.h> 66 67 #include <net80211/ieee80211_var.h> 68 #include <net80211/ieee80211_proto.h> 69 #include <net80211/ieee80211_ratectl.h> 70 #include <net80211/ieee80211_radiotap.h> 71 #include <net80211/ieee80211_vht.h> 72 73 #define LINUXKPI_NET80211 74 #include <net/mac80211.h> 75 76 #include <linux/workqueue.h> 77 #include <linux/rculist.h> 78 #include "linux_80211.h" 79 80 /* #define LKPI_80211_USE_SCANLIST */ 81 /* #define LKPI_80211_BGSCAN */ 82 #define LKPI_80211_WME 83 #define LKPI_80211_HW_CRYPTO 84 #define LKPI_80211_HT 85 #define LKPI_80211_VHT 86 87 #if defined(LKPI_80211_VHT) && !defined(LKPI_80211_HT) 88 #define LKPI_80211_HT 89 #endif 90 #if defined(LKPI_80211_HT) && !defined(LKPI_80211_HW_CRYPTO) 91 #define LKPI_80211_HW_CRYPTO 92 #endif 93 94 static MALLOC_DEFINE(M_LKPI80211, "lkpi80211", "LinuxKPI 80211 compat"); 95 96 /* XXX-BZ really want this and others in queue.h */ 97 #define TAILQ_ELEM_INIT(elm, field) do { \ 98 (elm)->field.tqe_next = NULL; \ 99 (elm)->field.tqe_prev = NULL; \ 100 } while (0) 101 102 /* -------------------------------------------------------------------------- */ 103 104 SYSCTL_DECL(_compat_linuxkpi); 105 SYSCTL_NODE(_compat_linuxkpi, OID_AUTO, 80211, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 106 "LinuxKPI 802.11 compatibility layer"); 107 108 static bool lkpi_order_scanlist = false; 109 SYSCTL_BOOL(_compat_linuxkpi_80211, OID_AUTO, order_scanlist, CTLFLAG_RW, 110 &lkpi_order_scanlist, 0, "Enable LinuxKPI 802.11 scan list shuffeling"); 111 112 #if defined(LKPI_80211_HW_CRYPTO) 113 static bool lkpi_hwcrypto = false; 114 SYSCTL_BOOL(_compat_linuxkpi_80211, OID_AUTO, hw_crypto, CTLFLAG_RDTUN, 115 &lkpi_hwcrypto, 0, "Enable LinuxKPI 802.11 hardware crypto offload"); 116 117 static bool lkpi_hwcrypto_tkip = false; 118 SYSCTL_BOOL(_compat_linuxkpi_80211, OID_AUTO, tkip, CTLFLAG_RDTUN, 119 &lkpi_hwcrypto_tkip, 0, "Enable LinuxKPI 802.11 TKIP crypto offload"); 120 #endif 121 122 /* Keep public for as long as header files are using it too. */ 123 int linuxkpi_debug_80211; 124 125 #ifdef LINUXKPI_DEBUG_80211 126 SYSCTL_INT(_compat_linuxkpi_80211, OID_AUTO, debug, CTLFLAG_RWTUN, 127 &linuxkpi_debug_80211, 0, "LinuxKPI 802.11 debug level"); 128 129 #define UNIMPLEMENTED if (linuxkpi_debug_80211 & D80211_TODO) \ 130 printf("XXX-TODO %s:%d: UNIMPLEMENTED\n", __func__, __LINE__) 131 #define TRACEOK(_fmt, ...) if (linuxkpi_debug_80211 & D80211_TRACEOK) \ 132 printf("%s:%d: TRACEPOINT " _fmt "\n", __func__, __LINE__, ##__VA_ARGS__) 133 #else 134 #define UNIMPLEMENTED do { } while (0) 135 #define TRACEOK(...) do { } while (0) 136 #endif 137 138 /* #define PREP_TX_INFO_DURATION (IEEE80211_TRANS_WAIT * 1000) */ 139 #ifndef PREP_TX_INFO_DURATION 140 #define PREP_TX_INFO_DURATION 0 /* Let the driver do its thing. */ 141 #endif 142 143 /* This is DSAP | SSAP | CTRL | ProtoID/OrgCode{3}. */ 144 const uint8_t rfc1042_header[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 }; 145 146 /* IEEE 802.11-05/0257r1 */ 147 const uint8_t bridge_tunnel_header[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 }; 148 149 /* IEEE 802.11e Table 20i-UP-to-AC mappings. */ 150 static const uint8_t ieee80211e_up_to_ac[] = { 151 IEEE80211_AC_BE, 152 IEEE80211_AC_BK, 153 IEEE80211_AC_BK, 154 IEEE80211_AC_BE, 155 IEEE80211_AC_VI, 156 IEEE80211_AC_VI, 157 IEEE80211_AC_VO, 158 IEEE80211_AC_VO, 159 #if 0 160 IEEE80211_AC_VO, /* We treat MGMT as TID 8, which is set as AC_VO */ 161 #endif 162 }; 163 164 const struct cfg80211_ops linuxkpi_mac80211cfgops = { 165 /* 166 * XXX TODO need a "glue layer" to link cfg80211 ops to 167 * mac80211 and to the driver or net80211. 168 * Can we pass some on 1:1? Need to compare the (*f)(). 169 */ 170 }; 171 172 #if 0 173 static struct lkpi_sta *lkpi_find_lsta_by_ni(struct lkpi_vif *, 174 struct ieee80211_node *); 175 #endif 176 static void lkpi_sw_scan_task(void *, int); 177 static void lkpi_80211_txq_tx_one(struct lkpi_sta *, struct mbuf *); 178 static void lkpi_80211_txq_task(void *, int); 179 static void lkpi_80211_lhw_rxq_task(void *, int); 180 static void lkpi_ieee80211_free_skb_mbuf(void *); 181 #ifdef LKPI_80211_WME 182 static int lkpi_wme_update(struct lkpi_hw *, struct ieee80211vap *, bool); 183 #endif 184 static void lkpi_ieee80211_wake_queues_locked(struct ieee80211_hw *); 185 186 static const char * 187 lkpi_rate_info_bw_to_str(enum rate_info_bw bw) 188 { 189 190 switch (bw) { 191 192 case RATE_INFO_BW_20: 193 return ("20"); 194 break; 195 case RATE_INFO_BW_5: 196 return ("5"); 197 break; 198 case RATE_INFO_BW_10: 199 return ("10"); 200 break; 201 case RATE_INFO_BW_40: 202 return ("40"); 203 break; 204 case RATE_INFO_BW_80: 205 return ("80"); 206 break; 207 case RATE_INFO_BW_160: 208 return ("160"); 209 break; 210 case RATE_INFO_BW_HE_RU: 211 IMPROVE("nl80211_he_ru_alloc"); 212 return ("HE_RU"); 213 break; 214 case RATE_INFO_BW_320: 215 return ("320"); 216 break; 217 case RATE_INFO_BW_EHT_RU: 218 IMPROVE("nl80211_eht_ru_alloc"); 219 return ("EHT_RU"); 220 break; 221 default: 222 return ("?"); 223 break; 224 } 225 } 226 227 static void 228 lkpi_nl80211_sta_info_to_str(struct sbuf *s, const char *prefix, 229 const uint64_t flags) 230 { 231 int bit, i; 232 233 sbuf_printf(s, "%s %#010jx", prefix, flags); 234 235 i = 0; 236 for (bit = 0; bit < BITS_PER_TYPE(flags); bit++) { 237 238 if ((flags & BIT_ULL(bit)) == 0) 239 continue; 240 241 #define EXPAND_CASE(_flag) \ 242 case NL80211_STA_INFO_ ## _flag: \ 243 sbuf_printf(s, "%c%s", (i == 0) ? '<' : ',', #_flag); \ 244 i++; \ 245 break; 246 247 switch (bit) { 248 EXPAND_CASE(BEACON_RX) 249 EXPAND_CASE(BEACON_SIGNAL_AVG) 250 EXPAND_CASE(BSS_PARAM) 251 EXPAND_CASE(CHAIN_SIGNAL) 252 EXPAND_CASE(CHAIN_SIGNAL_AVG) 253 EXPAND_CASE(CONNECTED_TIME) 254 EXPAND_CASE(INACTIVE_TIME) 255 EXPAND_CASE(SIGNAL) 256 EXPAND_CASE(SIGNAL_AVG) 257 EXPAND_CASE(STA_FLAGS) 258 EXPAND_CASE(RX_BITRATE) 259 EXPAND_CASE(RX_PACKETS) 260 EXPAND_CASE(RX_BYTES) 261 EXPAND_CASE(RX_DROP_MISC) 262 EXPAND_CASE(TX_BITRATE) 263 EXPAND_CASE(TX_PACKETS) 264 EXPAND_CASE(TX_BYTES) 265 EXPAND_CASE(TX_BYTES64) 266 EXPAND_CASE(RX_BYTES64) 267 EXPAND_CASE(TX_FAILED) 268 EXPAND_CASE(TX_RETRIES) 269 EXPAND_CASE(RX_DURATION) 270 EXPAND_CASE(TX_DURATION) 271 EXPAND_CASE(ACK_SIGNAL) 272 EXPAND_CASE(ACK_SIGNAL_AVG) 273 default: 274 sbuf_printf(s, "%c?%d", (i == 0) ? '<' : ',', bit); 275 break; 276 } 277 } 278 #undef EXPAND_CASE 279 if (i > 0) 280 sbuf_printf(s, ">"); 281 sbuf_printf(s, "\n"); 282 } 283 284 static void 285 lkpi_80211_dump_lvif_stas(struct lkpi_vif *lvif, struct sbuf *s) 286 { 287 struct lkpi_hw *lhw; 288 struct ieee80211_hw *hw; 289 struct ieee80211vap *vap; 290 struct ieee80211_vif *vif; 291 struct lkpi_sta *lsta; 292 struct ieee80211_sta *sta; 293 struct station_info sinfo; 294 int error; 295 296 vif = LVIF_TO_VIF(lvif); 297 vap = LVIF_TO_VAP(lvif); 298 lhw = vap->iv_ic->ic_softc; 299 hw = LHW_TO_HW(lhw); 300 301 wiphy_lock(hw->wiphy); 302 list_for_each_entry(lsta, &lvif->lsta_list, lsta_list) { 303 sta = LSTA_TO_STA(lsta); 304 305 sbuf_putc(s, '\n'); 306 sbuf_printf(s, "lsta %p sta %p added_to_drv %d\n", lsta, sta, lsta->added_to_drv); 307 308 memset(&sinfo, 0, sizeof(sinfo)); 309 error = lkpi_80211_mo_sta_statistics(hw, vif, sta, &sinfo); 310 if (error == EEXIST) /* Not added to driver. */ 311 continue; 312 if (error == ENOTSUPP) { 313 sbuf_printf(s, " sta_statistics not supported\n"); 314 continue; 315 } 316 if (error != 0) { 317 sbuf_printf(s, " sta_statistics failed: %d\n", error); 318 continue; 319 } 320 321 /* If no RX_BITRATE is reported, try to fill it in from the lsta sinfo. */ 322 if ((sinfo.filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) == 0 && 323 (lsta->sinfo.filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) != 0) { 324 memcpy(&sinfo.rxrate, &lsta->sinfo.rxrate, sizeof(sinfo.rxrate)); 325 sinfo.filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE); 326 } 327 /* If no CHAIN_SIGNAL is reported, try to fill it in from the lsta sinfo. */ 328 if ((sinfo.filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) == 0 && 329 (lsta->sinfo.filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) != 0) { 330 sinfo.chains = lsta->sinfo.chains; 331 memcpy(sinfo.chain_signal, lsta->sinfo.chain_signal, 332 sizeof(sinfo.chain_signal)); 333 sinfo.filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL); 334 } 335 336 lkpi_nl80211_sta_info_to_str(s, " nl80211_sta_info (valid fields)", sinfo.filled); 337 sbuf_printf(s, " connected_time %u inactive_time %u\n", 338 sinfo.connected_time, sinfo.inactive_time); 339 sbuf_printf(s, " rx_bytes %ju rx_packets %u rx_dropped_misc %u\n", 340 (uintmax_t)sinfo.rx_bytes, sinfo.rx_packets, sinfo.rx_dropped_misc); 341 sbuf_printf(s, " rx_duration %ju rx_beacon %u rx_beacon_signal_avg %d\n", 342 (uintmax_t)sinfo.rx_duration, sinfo.rx_beacon, (int8_t)sinfo.rx_beacon_signal_avg); 343 344 sbuf_printf(s, " tx_bytes %ju tx_packets %u tx_failed %u\n", 345 (uintmax_t)sinfo.tx_bytes, sinfo.tx_packets, sinfo.tx_failed); 346 sbuf_printf(s, " tx_duration %ju tx_retries %u\n", 347 (uintmax_t)sinfo.tx_duration, sinfo.tx_retries); 348 349 sbuf_printf(s, " signal %d signal_avg %d ack_signal %d avg_ack_signal %d\n", 350 sinfo.signal, sinfo.signal_avg, sinfo.ack_signal, sinfo.avg_ack_signal); 351 sbuf_printf(s, " generation %d assoc_req_ies_len %zu chains %#04x\n", 352 sinfo.generation, sinfo.assoc_req_ies_len, sinfo.chains); 353 354 for (int i = 0; i < nitems(sinfo.chain_signal) && i < IEEE80211_MAX_CHAINS; i++) { 355 if (!(sinfo.chains & BIT(i))) 356 continue; 357 sbuf_printf(s, " chain[%d] signal %d signal_avg %d\n", 358 i, (int8_t)sinfo.chain_signal[i], (int8_t)sinfo.chain_signal_avg[i]); 359 } 360 361 /* assoc_req_ies, bss_param, sta_flags */ 362 363 sbuf_printf(s, " rxrate: flags %b bw %u(%s) legacy %u kbit/s mcs %u nss %u\n", 364 sinfo.rxrate.flags, CFG80211_RATE_INFO_FLAGS_BITS, 365 sinfo.rxrate.bw, lkpi_rate_info_bw_to_str(sinfo.rxrate.bw), 366 sinfo.rxrate.legacy * 100, 367 sinfo.rxrate.mcs, sinfo.rxrate.nss); 368 sbuf_printf(s, " he_dcm %u he_gi %u he_ru_alloc %u eht_gi %u\n", 369 sinfo.rxrate.he_dcm, sinfo.rxrate.he_gi, sinfo.rxrate.he_ru_alloc, 370 sinfo.rxrate.eht_gi); 371 sbuf_printf(s, " txrate: flags %b bw %u(%s) legacy %u kbit/s mcs %u nss %u\n", 372 sinfo.txrate.flags, CFG80211_RATE_INFO_FLAGS_BITS, 373 sinfo.txrate.bw, lkpi_rate_info_bw_to_str(sinfo.txrate.bw), 374 sinfo.txrate.legacy * 100, 375 sinfo.txrate.mcs, sinfo.txrate.nss); 376 sbuf_printf(s, " he_dcm %u he_gi %u he_ru_alloc %u eht_gi %u\n", 377 sinfo.txrate.he_dcm, sinfo.txrate.he_gi, sinfo.txrate.he_ru_alloc, 378 sinfo.txrate.eht_gi); 379 } 380 wiphy_unlock(hw->wiphy); 381 } 382 383 static int 384 lkpi_80211_dump_stas(SYSCTL_HANDLER_ARGS) 385 { 386 struct lkpi_vif *lvif; 387 struct sbuf s; 388 389 if (req->newptr) 390 return (EPERM); 391 392 lvif = (struct lkpi_vif *)arg1; 393 394 sbuf_new_for_sysctl(&s, NULL, 1024, req); 395 396 lkpi_80211_dump_lvif_stas(lvif, &s); 397 398 sbuf_finish(&s); 399 sbuf_delete(&s); 400 401 return (0); 402 } 403 404 static enum ieee80211_sta_rx_bandwidth 405 lkpi_cw_to_rx_bw(enum nl80211_chan_width cw) 406 { 407 switch (cw) { 408 case NL80211_CHAN_WIDTH_320: 409 return (IEEE80211_STA_RX_BW_320); 410 case NL80211_CHAN_WIDTH_160: 411 case NL80211_CHAN_WIDTH_80P80: 412 return (IEEE80211_STA_RX_BW_160); 413 case NL80211_CHAN_WIDTH_80: 414 return (IEEE80211_STA_RX_BW_80); 415 case NL80211_CHAN_WIDTH_40: 416 return (IEEE80211_STA_RX_BW_40); 417 case NL80211_CHAN_WIDTH_20: 418 case NL80211_CHAN_WIDTH_20_NOHT: 419 return (IEEE80211_STA_RX_BW_20); 420 case NL80211_CHAN_WIDTH_5: 421 case NL80211_CHAN_WIDTH_10: 422 /* Unsupported input. */ 423 return (IEEE80211_STA_RX_BW_20); 424 } 425 } 426 427 static enum nl80211_chan_width 428 lkpi_rx_bw_to_cw(enum ieee80211_sta_rx_bandwidth rx_bw) 429 { 430 switch (rx_bw) { 431 case IEEE80211_STA_RX_BW_20: 432 return (NL80211_CHAN_WIDTH_20); /* _NOHT */ 433 case IEEE80211_STA_RX_BW_40: 434 return (NL80211_CHAN_WIDTH_40); 435 case IEEE80211_STA_RX_BW_80: 436 return (NL80211_CHAN_WIDTH_80); 437 case IEEE80211_STA_RX_BW_160: 438 return (NL80211_CHAN_WIDTH_160); /* 80P80 */ 439 case IEEE80211_STA_RX_BW_320: 440 return (NL80211_CHAN_WIDTH_320); 441 } 442 } 443 444 static void 445 lkpi_sync_chanctx_cw_from_rx_bw(struct ieee80211_hw *hw, 446 struct ieee80211_vif *vif, struct ieee80211_sta *sta) 447 { 448 struct ieee80211_chanctx_conf *chanctx_conf; 449 enum ieee80211_sta_rx_bandwidth old_bw; 450 uint32_t changed; 451 452 chanctx_conf = rcu_dereference_protected(vif->bss_conf.chanctx_conf, 453 lockdep_is_held(&hw->wiphy->mtx)); 454 if (chanctx_conf == NULL) 455 return; 456 457 old_bw = lkpi_cw_to_rx_bw(chanctx_conf->def.width); 458 if (old_bw == sta->deflink.bandwidth) 459 return; 460 461 chanctx_conf->def.width = lkpi_rx_bw_to_cw(sta->deflink.bandwidth); 462 if (chanctx_conf->def.width == NL80211_CHAN_WIDTH_20 && 463 !sta->deflink.ht_cap.ht_supported) 464 chanctx_conf->def.width = NL80211_CHAN_WIDTH_20_NOHT; 465 466 chanctx_conf->min_def = chanctx_conf->def; 467 468 vif->bss_conf.chanreq.oper.width = chanctx_conf->def.width; 469 470 changed = IEEE80211_CHANCTX_CHANGE_MIN_WIDTH; 471 changed |= IEEE80211_CHANCTX_CHANGE_WIDTH; 472 lkpi_80211_mo_change_chanctx(hw, chanctx_conf, changed); 473 } 474 475 #if defined(LKPI_80211_HT) 476 static void 477 lkpi_sta_sync_ht_from_ni(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 478 struct ieee80211_sta *sta, struct ieee80211_node *ni) 479 { 480 struct ieee80211vap *vap; 481 uint8_t *ie; 482 struct ieee80211_ht_cap *htcap; 483 struct ieee80211_sta_ht_cap *ht_cap, *sta_ht_cap; 484 enum nl80211_band band; 485 int i, rx_nss; 486 487 if ((ni->ni_flags & IEEE80211_NODE_HT) == 0) { 488 sta->deflink.ht_cap.ht_supported = false; 489 return; 490 } 491 492 sta->deflink.ht_cap.ht_supported = true; 493 494 /* htcap->ampdu_params_info */ 495 vap = ni->ni_vap; 496 sta->deflink.ht_cap.ampdu_density = _IEEE80211_MASKSHIFT(ni->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY); 497 if (sta->deflink.ht_cap.ampdu_density > vap->iv_ampdu_density) 498 sta->deflink.ht_cap.ampdu_density = vap->iv_ampdu_density; 499 sta->deflink.ht_cap.ampdu_factor = _IEEE80211_MASKSHIFT(ni->ni_htparam, IEEE80211_HTCAP_MAXRXAMPDU); 500 if (sta->deflink.ht_cap.ampdu_factor > vap->iv_ampdu_rxmax) 501 sta->deflink.ht_cap.ampdu_factor = vap->iv_ampdu_rxmax; 502 503 ie = ni->ni_ies.htcap_ie; 504 KASSERT(ie != NULL, ("%s: HT but no htcap_ie on ni %p\n", __func__, ni)); 505 if (ie[0] == IEEE80211_ELEMID_VENDOR) 506 ie += 4; 507 ie += 2; 508 htcap = (struct ieee80211_ht_cap *)ie; 509 sta->deflink.ht_cap.cap = htcap->cap_info; 510 sta->deflink.ht_cap.mcs = htcap->mcs; 511 512 /* 513 * 802.11n-2009 20.6 Parameters for HT MCSs gives the mandatory/ 514 * optional MCS for Nss=1..4. We need to check the first four 515 * MCS sets from the Rx MCS Bitmask; then there is MCS 32 and 516 * MCS33.. is UEQM. 517 */ 518 band = vif->bss_conf.chanctx_conf->def.chan->band; 519 ht_cap = &hw->wiphy->bands[band]->ht_cap; 520 sta_ht_cap = &sta->deflink.ht_cap; 521 rx_nss = 0; 522 for (i = 0; i < 4; i++) { 523 TRACEOK("HT rx_mask[%d] sta %#04x & hw %#04x", i, 524 sta_ht_cap->mcs.rx_mask[i], ht_cap->mcs.rx_mask[i]); 525 sta_ht_cap->mcs.rx_mask[i] = 526 sta_ht_cap->mcs.rx_mask[i] & ht_cap->mcs.rx_mask[i]; 527 /* XXX-BZ masking unequal modulation? */ 528 529 if (sta_ht_cap->mcs.rx_mask[i] != 0) 530 rx_nss++; 531 } 532 if (rx_nss > 0) { 533 TRACEOK("HT rx_nss = max(%d, %d)", rx_nss, sta->deflink.rx_nss); 534 sta->deflink.rx_nss = MAX(rx_nss, sta->deflink.rx_nss); 535 } else { 536 sta->deflink.ht_cap.ht_supported = false; 537 return; 538 } 539 540 if ((sta->deflink.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) != 0 && 541 IEEE80211_IS_CHAN_HT40(ni->ni_chan)) 542 sta->deflink.bandwidth = IEEE80211_STA_RX_BW_40; 543 else 544 sta->deflink.bandwidth = IEEE80211_STA_RX_BW_20; 545 546 IMPROVE("sta->wme"); 547 548 if (sta->deflink.ht_cap.cap & IEEE80211_HT_CAP_MAX_AMSDU) 549 sta->deflink.agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_7935; 550 else 551 sta->deflink.agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_3839; 552 sta->deflink.agg.max_rc_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_BA; 553 #ifdef __handled_by_driver__ /* iwlwifi only? actually unused? */ 554 for (i = 0; i < nitems(sta.deflink.agg.max_tid_amsdu_len); i++) { 555 sta->deflink.agg.max_tid_amsdu_len[j] = ; 556 } 557 #endif 558 } 559 #endif 560 561 #if defined(LKPI_80211_VHT) 562 static void 563 lkpi_sta_sync_vht_from_ni(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 564 struct ieee80211_sta *sta, struct ieee80211_node *ni) 565 { 566 struct ieee80211_sta_vht_cap *vht_cap, *sta_vht_cap;; 567 enum ieee80211_sta_rx_bandwidth bw; 568 enum nl80211_band band; 569 uint32_t width; 570 int rx_nss; 571 uint16_t rx_map, tx_map; 572 573 if ((ni->ni_flags & IEEE80211_NODE_VHT) == 0 || 574 !IEEE80211_IS_CHAN_VHT_5GHZ(ni->ni_chan)) { 575 sta->deflink.vht_cap.vht_supported = false; 576 return; 577 } 578 579 sta->deflink.vht_cap.vht_supported = true; 580 581 sta->deflink.vht_cap.cap = ni->ni_vhtcap; 582 sta->deflink.vht_cap.vht_mcs = ni->ni_vht_mcsinfo; 583 584 /* 585 * If VHT20/40 are selected do not update the bandwidth 586 * from HT but stya on VHT. 587 */ 588 if (ni->ni_vht_chanwidth == IEEE80211_VHT_CHANWIDTH_USE_HT) 589 goto skip_bw; 590 591 bw = sta->deflink.bandwidth; 592 width = (sta->deflink.vht_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK); 593 switch (width) { 594 /* Deprecated. */ 595 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ: 596 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ: 597 bw = IEEE80211_STA_RX_BW_160; 598 break; 599 default: 600 /* Check if we do support 160Mhz somehow after all. */ 601 if ((sta->deflink.vht_cap.cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) != 0) 602 bw = IEEE80211_STA_RX_BW_160; 603 else 604 bw = IEEE80211_STA_RX_BW_80; 605 } 606 /* 607 * While we can set what is possibly supported we also need to be 608 * on a channel which supports that bandwidth; e.g., we can support 609 * VHT160 but the AP only does VHT80. 610 * Further ni_chan will also have filtered out what we disabled 611 * by configuration. 612 * Once net80211 channel selection is fixed for 802.11-2020 and 613 * VHT160 we can possibly spare ourselves the above. 614 */ 615 if (bw == IEEE80211_STA_RX_BW_160 && 616 !IEEE80211_IS_CHAN_VHT160(ni->ni_chan) && 617 !IEEE80211_IS_CHAN_VHT80P80(ni->ni_chan)) 618 bw = IEEE80211_STA_RX_BW_80; 619 if (bw == IEEE80211_STA_RX_BW_80 && 620 !IEEE80211_IS_CHAN_VHT80(ni->ni_chan)) 621 bw = sta->deflink.bandwidth; 622 sta->deflink.bandwidth = bw; 623 skip_bw: 624 625 band = vif->bss_conf.chanctx_conf->def.chan->band; 626 vht_cap = &hw->wiphy->bands[band]->vht_cap; 627 sta_vht_cap = &sta->deflink.vht_cap; 628 629 rx_nss = 0; 630 rx_map = tx_map = 0; 631 for (int i = 7; i >= 0; i--) { 632 uint8_t card, sta; 633 634 card = (vht_cap->vht_mcs.rx_mcs_map >> (2 * i)) & 0x3; 635 sta = (sta_vht_cap->vht_mcs.rx_mcs_map >> (2 * i)) & 0x3; 636 if (sta != IEEE80211_VHT_MCS_NOT_SUPPORTED) { 637 if (card == IEEE80211_VHT_MCS_NOT_SUPPORTED) 638 sta = IEEE80211_VHT_MCS_NOT_SUPPORTED; 639 else { 640 sta = MIN(sta, card); 641 rx_nss = i + 1; 642 } 643 } 644 rx_map |= (sta << (2 * i)); 645 646 card = (vht_cap->vht_mcs.tx_mcs_map >> (2 * i)) & 0x3; 647 sta = (sta_vht_cap->vht_mcs.tx_mcs_map >> (2 * i)) & 0x3; 648 if (sta != IEEE80211_VHT_MCS_NOT_SUPPORTED) { 649 if (card == IEEE80211_VHT_MCS_NOT_SUPPORTED) 650 sta = IEEE80211_VHT_MCS_NOT_SUPPORTED; 651 else 652 sta = MIN(sta, card); 653 } 654 tx_map |= (sta << (2 * i)); 655 } 656 TRACEOK("VHT rx_mcs_map %#010x->%#010x, tx_mcs_map %#010x->%#010x, rx_nss = %d", 657 sta_vht_cap->vht_mcs.rx_mcs_map, rx_map, 658 sta_vht_cap->vht_mcs.tx_mcs_map, tx_map, rx_nss); 659 sta_vht_cap->vht_mcs.rx_mcs_map = rx_map; 660 sta_vht_cap->vht_mcs.tx_mcs_map = tx_map; 661 if (rx_nss > 0) { 662 TRACEOK("VHT rx_nss = max(%d, %d)", rx_nss, sta->deflink.rx_nss); 663 sta->deflink.rx_nss = MAX(rx_nss, sta->deflink.rx_nss); 664 } else { 665 sta->deflink.vht_cap.vht_supported = false; 666 return; 667 } 668 669 switch (sta->deflink.vht_cap.cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK) { 670 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454: 671 sta->deflink.agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_11454; 672 break; 673 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991: 674 sta->deflink.agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_7991; 675 break; 676 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895: 677 default: 678 sta->deflink.agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_3895; 679 break; 680 } 681 } 682 #endif 683 684 static void 685 lkpi_sta_sync_from_ni(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 686 struct ieee80211_sta *sta, struct ieee80211_node *ni, bool updchnctx) 687 { 688 689 /* 690 * Ensure rx_nss is at least 1 as otherwise drivers run into 691 * unexpected problems. 692 */ 693 sta->deflink.rx_nss = 1; 694 695 #if defined(LKPI_80211_HT) 696 lkpi_sta_sync_ht_from_ni(hw, vif, sta, ni); 697 #endif 698 #if defined(LKPI_80211_VHT) 699 lkpi_sta_sync_vht_from_ni(hw, vif, sta, ni); 700 #endif 701 702 /* 703 * We are also called from node allocation which net80211 704 * can do even on `ifconfig down`; in that case the chanctx 705 * may still be valid and we get a discrepancy between 706 * sta and chanctx. Thus do not try to update the chanctx 707 * when called from lkpi_lsta_alloc(). 708 */ 709 if (updchnctx) 710 lkpi_sync_chanctx_cw_from_rx_bw(hw, vif, sta); 711 } 712 713 static uint8_t 714 lkpi_get_max_rx_chains(struct ieee80211_node *ni) 715 { 716 uint8_t chains; 717 #if defined(LKPI_80211_HT) || defined(LKPI_80211_VHT) 718 struct lkpi_sta *lsta; 719 struct ieee80211_sta *sta; 720 721 lsta = ni->ni_drv_data; 722 sta = LSTA_TO_STA(lsta); 723 #endif 724 725 chains = 1; 726 #if defined(LKPI_80211_HT) 727 IMPROVE("We should factor counting MCS/NSS out for sync and here"); 728 if (sta->deflink.ht_cap.ht_supported) 729 chains = MAX(chains, sta->deflink.rx_nss); 730 #endif 731 732 #if defined(LKPI_80211_VHT) 733 if (sta->deflink.vht_cap.vht_supported) 734 chains = MAX(chains, sta->deflink.rx_nss); 735 #endif 736 737 return (chains); 738 } 739 740 static void 741 lkpi_lsta_dump(struct lkpi_sta *lsta, struct ieee80211_node *ni, 742 const char *_f, int _l) 743 { 744 745 #ifdef LINUXKPI_DEBUG_80211 746 if ((linuxkpi_debug_80211 & D80211_TRACE_STA) == 0) 747 return; 748 if (lsta == NULL) 749 return; 750 751 printf("%s:%d lsta %p ni %p sta %p\n", 752 _f, _l, lsta, ni, &lsta->sta); 753 if (ni != NULL) 754 ieee80211_dump_node(NULL, ni); 755 printf("\ttxq_task txq len %d mtx\n", mbufq_len(&lsta->txq)); 756 printf("\tkc %p state %d added_to_drv %d in_mgd %d\n", 757 &lsta->kc[0], lsta->state, lsta->added_to_drv, lsta->in_mgd); 758 #endif 759 } 760 761 static void 762 lkpi_lsta_remove(struct lkpi_sta *lsta, struct lkpi_vif *lvif) 763 { 764 765 lockdep_assert_wiphy(lsta->hw->wiphy); 766 767 KASSERT(!list_empty(&lsta->lsta_list), 768 ("%s: lsta %p ni %p\n", __func__, lsta, lsta->ni)); 769 list_del_init(&lsta->lsta_list); 770 } 771 772 static struct lkpi_sta * 773 lkpi_lsta_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN], 774 struct ieee80211_hw *hw, struct ieee80211_node *ni) 775 { 776 struct lkpi_sta *lsta; 777 struct lkpi_vif *lvif; 778 struct ieee80211_vif *vif; 779 struct ieee80211_sta *sta; 780 int band, i, tid; 781 782 lsta = malloc(sizeof(*lsta) + hw->sta_data_size, M_LKPI80211, 783 M_NOWAIT | M_ZERO); 784 if (lsta == NULL) 785 return (NULL); 786 787 lsta->hw = hw; 788 lsta->added_to_drv = false; 789 lsta->state = IEEE80211_STA_NOTEXIST; 790 /* 791 * Link the ni to the lsta here without taking a reference. 792 * For one we would have to take the reference in node_init() 793 * as ieee80211_alloc_node() will initialise the refcount after us. 794 * For the other a ni and an lsta are 1:1 mapped and always together 795 * from [ic_]node_alloc() to [ic_]node_free() so we are essentally 796 * using the ni references for the lsta as well despite it being 797 * two separate allocations. 798 */ 799 lsta->ni = ni; 800 /* The back-pointer "drv_data" to net80211_node let's us get lsta. */ 801 ni->ni_drv_data = lsta; 802 803 lvif = VAP_TO_LVIF(vap); 804 vif = LVIF_TO_VIF(lvif); 805 sta = LSTA_TO_STA(lsta); 806 807 IEEE80211_ADDR_COPY(sta->addr, mac); 808 809 /* TXQ */ 810 for (tid = 0; tid < nitems(sta->txq); tid++) { 811 struct lkpi_txq *ltxq; 812 813 /* We are not limiting ourselves to hw.queues here. */ 814 ltxq = malloc(sizeof(*ltxq) + hw->txq_data_size, 815 M_LKPI80211, M_NOWAIT | M_ZERO); 816 if (ltxq == NULL) 817 goto cleanup; 818 /* iwlwifi//mvm/sta.c::tid_to_mac80211_ac[] */ 819 if (tid == IEEE80211_NUM_TIDS) { 820 if (!ieee80211_hw_check(hw, STA_MMPDU_TXQ)) { 821 free(ltxq, M_LKPI80211); 822 continue; 823 } 824 IMPROVE("AP/if we support non-STA here too"); 825 ltxq->txq.ac = IEEE80211_AC_VO; 826 } else { 827 ltxq->txq.ac = ieee80211e_up_to_ac[tid & 7]; 828 } 829 ltxq->seen_dequeue = false; 830 ltxq->stopped = false; 831 ltxq->txq.vif = vif; 832 ltxq->txq.tid = tid; 833 ltxq->txq.sta = sta; 834 TAILQ_ELEM_INIT(ltxq, txq_entry); 835 skb_queue_head_init(<xq->skbq); 836 LKPI_80211_LTXQ_LOCK_INIT(ltxq); 837 sta->txq[tid] = <xq->txq; 838 } 839 840 /* Deflink information. */ 841 for (band = 0; band < NUM_NL80211_BANDS; band++) { 842 struct ieee80211_supported_band *supband; 843 844 supband = hw->wiphy->bands[band]; 845 if (supband == NULL) 846 continue; 847 848 for (i = 0; i < supband->n_bitrates; i++) { 849 switch (band) { 850 case NL80211_BAND_2GHZ: 851 switch (supband->bitrates[i].bitrate) { 852 case 240: /* 11g only */ 853 case 120: /* 11g only */ 854 case 110: 855 case 60: /* 11g only */ 856 case 55: 857 case 20: 858 case 10: 859 sta->deflink.supp_rates[band] |= BIT(i); 860 break; 861 } 862 break; 863 case NL80211_BAND_5GHZ: 864 switch (supband->bitrates[i].bitrate) { 865 case 240: 866 case 120: 867 case 60: 868 sta->deflink.supp_rates[band] |= BIT(i); 869 break; 870 } 871 break; 872 } 873 } 874 } 875 876 sta->deflink.smps_mode = IEEE80211_SMPS_OFF; 877 sta->deflink.bandwidth = IEEE80211_STA_RX_BW_20; 878 sta->deflink.rx_nss = 1; 879 sta->deflink.sta = sta; 880 881 lkpi_sta_sync_from_ni(hw, vif, sta, ni, false); 882 883 IMPROVE("he, eht, bw_320, ... smps_mode, .."); 884 885 /* Link configuration. */ 886 IEEE80211_ADDR_COPY(sta->deflink.addr, sta->addr); 887 sta->link[0] = &sta->deflink; 888 for (i = 1; i < nitems(sta->link); i++) { 889 IMPROVE("more links; only link[0] = deflink currently."); 890 } 891 IMPROVE("11be"); 892 sta->mlo = false; 893 894 /* Deferred TX path. */ 895 LKPI_80211_LSTA_TXQ_LOCK_INIT(lsta); 896 TASK_INIT(&lsta->txq_task, 0, lkpi_80211_txq_task, lsta); 897 mbufq_init(&lsta->txq, 32 * NAPI_POLL_WEIGHT); 898 lsta->txq_ready = true; 899 900 return (lsta); 901 902 cleanup: 903 for (; tid >= 0; tid--) { 904 struct lkpi_txq *ltxq; 905 906 ltxq = TXQ_TO_LTXQ(sta->txq[tid]); 907 LKPI_80211_LTXQ_LOCK_DESTROY(ltxq); 908 free(sta->txq[tid], M_LKPI80211); 909 } 910 free(lsta, M_LKPI80211); 911 return (NULL); 912 } 913 914 static void 915 lkpi_lsta_free(struct lkpi_sta *lsta, struct ieee80211_node *ni) 916 { 917 struct mbuf *m; 918 919 if (lsta->added_to_drv) 920 panic("%s: Trying to free an lsta still known to firmware: " 921 "lsta %p ni %p added_to_drv %d\n", 922 __func__, lsta, ni, lsta->added_to_drv); 923 924 /* XXX-BZ free resources, ... */ 925 IMPROVE(); 926 927 /* Drain sta->txq[] */ 928 929 LKPI_80211_LSTA_TXQ_LOCK(lsta); 930 lsta->txq_ready = false; 931 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 932 933 /* Drain taskq, won't be restarted until added_to_drv is set again. */ 934 while (taskqueue_cancel(taskqueue_thread, &lsta->txq_task, NULL) != 0) 935 taskqueue_drain(taskqueue_thread, &lsta->txq_task); 936 937 /* Flush mbufq (make sure to release ni refs!). */ 938 m = mbufq_dequeue(&lsta->txq); 939 while (m != NULL) { 940 struct ieee80211_node *nim; 941 942 nim = (struct ieee80211_node *)m->m_pkthdr.rcvif; 943 if (nim != NULL) 944 ieee80211_free_node(nim); 945 m_freem(m); 946 m = mbufq_dequeue(&lsta->txq); 947 } 948 KASSERT(mbufq_empty(&lsta->txq), ("%s: lsta %p has txq len %d != 0\n", 949 __func__, lsta, mbufq_len(&lsta->txq))); 950 LKPI_80211_LSTA_TXQ_LOCK_DESTROY(lsta); 951 952 /* Remove lsta from vif; that is done by the state machine. Should assert it? */ 953 954 IMPROVE("Make sure everything is cleaned up."); 955 956 /* Free lsta. */ 957 lsta->ni = NULL; 958 ni->ni_drv_data = NULL; 959 free(lsta, M_LKPI80211); 960 } 961 962 963 static enum nl80211_band 964 lkpi_net80211_chan_to_nl80211_band(struct ieee80211_channel *c) 965 { 966 967 if (IEEE80211_IS_CHAN_2GHZ(c)) 968 return (NL80211_BAND_2GHZ); 969 else if (IEEE80211_IS_CHAN_5GHZ(c)) 970 return (NL80211_BAND_5GHZ); 971 #ifdef __notyet__ 972 else if () 973 return (NL80211_BAND_6GHZ); 974 else if () 975 return (NL80211_BAND_60GHZ); 976 else if (IEEE80211_IS_CHAN_GSM(c)) 977 return (NL80211_BAND_XXX); 978 #endif 979 else 980 panic("%s: unsupported band. c %p flags %#x\n", 981 __func__, c, c->ic_flags); 982 } 983 984 static uint32_t 985 lkpi_nl80211_band_to_net80211_band(enum nl80211_band band) 986 { 987 988 /* XXX-BZ this is just silly; net80211 is too convoluted. */ 989 /* IEEE80211_CHAN_A / _G / .. doesn't really work either. */ 990 switch (band) { 991 case NL80211_BAND_2GHZ: 992 return (IEEE80211_CHAN_2GHZ); 993 break; 994 case NL80211_BAND_5GHZ: 995 return (IEEE80211_CHAN_5GHZ); 996 break; 997 case NL80211_BAND_60GHZ: 998 break; 999 case NL80211_BAND_6GHZ: 1000 break; 1001 default: 1002 panic("%s: unsupported band %u\n", __func__, band); 1003 break; 1004 } 1005 1006 IMPROVE(); 1007 return (0x00); 1008 } 1009 1010 #ifdef LINUXKPI_DEBUG_80211 1011 static const char * 1012 lkpi_nl80211_band_name(enum nl80211_band band) 1013 { 1014 switch (band) { 1015 case NL80211_BAND_2GHZ: 1016 return "2Ghz"; 1017 break; 1018 case NL80211_BAND_5GHZ: 1019 return "5Ghz"; 1020 break; 1021 case NL80211_BAND_60GHZ: 1022 return "60Ghz"; 1023 break; 1024 case NL80211_BAND_6GHZ: 1025 return "6Ghz"; 1026 break; 1027 default: 1028 panic("%s: unsupported band %u\n", __func__, band); 1029 break; 1030 } 1031 } 1032 #endif 1033 1034 #if 0 1035 static enum ieee80211_ac_numbers 1036 lkpi_ac_net_to_l80211(int ac) 1037 { 1038 1039 switch (ac) { 1040 case WME_AC_VO: 1041 return (IEEE80211_AC_VO); 1042 case WME_AC_VI: 1043 return (IEEE80211_AC_VI); 1044 case WME_AC_BE: 1045 return (IEEE80211_AC_BE); 1046 case WME_AC_BK: 1047 return (IEEE80211_AC_BK); 1048 default: 1049 printf("%s: invalid WME_AC_* input: ac = %d\n", __func__, ac); 1050 return (IEEE80211_AC_BE); 1051 } 1052 } 1053 #endif 1054 1055 static enum nl80211_iftype 1056 lkpi_opmode_to_vif_type(enum ieee80211_opmode opmode) 1057 { 1058 1059 switch (opmode) { 1060 case IEEE80211_M_IBSS: 1061 return (NL80211_IFTYPE_ADHOC); 1062 break; 1063 case IEEE80211_M_STA: 1064 return (NL80211_IFTYPE_STATION); 1065 break; 1066 case IEEE80211_M_WDS: 1067 return (NL80211_IFTYPE_WDS); 1068 break; 1069 case IEEE80211_M_HOSTAP: 1070 return (NL80211_IFTYPE_AP); 1071 break; 1072 case IEEE80211_M_MONITOR: 1073 return (NL80211_IFTYPE_MONITOR); 1074 break; 1075 case IEEE80211_M_MBSS: 1076 return (NL80211_IFTYPE_MESH_POINT); 1077 break; 1078 case IEEE80211_M_AHDEMO: 1079 /* FALLTHROUGH */ 1080 default: 1081 printf("ERROR: %s: unsupported opmode %d\n", __func__, opmode); 1082 /* FALLTHROUGH */ 1083 } 1084 return (NL80211_IFTYPE_UNSPECIFIED); 1085 } 1086 1087 #ifdef LKPI_80211_HW_CRYPTO 1088 static const char * 1089 lkpi_cipher_suite_to_name(uint32_t wlan_cipher_suite) 1090 { 1091 switch (wlan_cipher_suite) { 1092 case WLAN_CIPHER_SUITE_WEP40: 1093 return ("WEP40"); 1094 case WLAN_CIPHER_SUITE_WEP104: 1095 return ("WEP104"); 1096 case WLAN_CIPHER_SUITE_TKIP: 1097 return ("TKIP"); 1098 case WLAN_CIPHER_SUITE_CCMP: 1099 return ("CCMP"); 1100 case WLAN_CIPHER_SUITE_CCMP_256: 1101 return ("CCMP_256"); 1102 case WLAN_CIPHER_SUITE_GCMP: 1103 return ("GCMP"); 1104 case WLAN_CIPHER_SUITE_GCMP_256: 1105 return ("GCMP_256"); 1106 case WLAN_CIPHER_SUITE_AES_CMAC: 1107 return ("AES_CMAC"); 1108 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 1109 return ("BIP_CMAC_256"); 1110 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 1111 return ("BIP_GMAC_128"); 1112 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 1113 return ("BIP_GMAC_256"); 1114 default: 1115 return ("??"); 1116 } 1117 } 1118 1119 static uint32_t 1120 lkpi_l80211_to_net80211_cyphers(struct ieee80211com *ic, 1121 uint32_t wlan_cipher_suite) 1122 { 1123 switch (wlan_cipher_suite) { 1124 case WLAN_CIPHER_SUITE_WEP40: 1125 return (IEEE80211_CRYPTO_WEP); 1126 case WLAN_CIPHER_SUITE_WEP104: 1127 return (IEEE80211_CRYPTO_WEP); 1128 case WLAN_CIPHER_SUITE_TKIP: 1129 return (IEEE80211_CRYPTO_TKIP); 1130 case WLAN_CIPHER_SUITE_CCMP: 1131 return (IEEE80211_CRYPTO_AES_CCM); 1132 case WLAN_CIPHER_SUITE_CCMP_256: 1133 return (IEEE80211_CRYPTO_AES_CCM_256); 1134 case WLAN_CIPHER_SUITE_GCMP: 1135 return (IEEE80211_CRYPTO_AES_GCM_128); 1136 case WLAN_CIPHER_SUITE_GCMP_256: 1137 return (IEEE80211_CRYPTO_AES_GCM_256); 1138 case WLAN_CIPHER_SUITE_AES_CMAC: 1139 return (IEEE80211_CRYPTO_BIP_CMAC_128); 1140 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 1141 return (IEEE80211_CRYPTO_BIP_CMAC_256); 1142 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 1143 return (IEEE80211_CRYPTO_BIP_GMAC_128); 1144 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 1145 return (IEEE80211_CRYPTO_BIP_GMAC_256); 1146 default: 1147 ic_printf(ic, "%s: unknown WLAN Cipher Suite %#08x | %u (%s)\n", 1148 __func__, 1149 wlan_cipher_suite >> 8, wlan_cipher_suite & 0xff, 1150 lkpi_cipher_suite_to_name(wlan_cipher_suite)); 1151 return (0); 1152 } 1153 } 1154 1155 static uint32_t 1156 lkpi_net80211_to_l80211_cipher_suite(uint32_t cipher, uint8_t keylen) 1157 { 1158 1159 switch (cipher) { 1160 case IEEE80211_CIPHER_WEP: 1161 if (keylen == (40/NBBY)) 1162 return (WLAN_CIPHER_SUITE_WEP40); 1163 else if (keylen == (104/NBBY)) 1164 return (WLAN_CIPHER_SUITE_WEP104); 1165 else { 1166 printf("%s: WEP with unsupported keylen %d\n", 1167 __func__, keylen * NBBY); 1168 return (0); 1169 } 1170 break; 1171 case IEEE80211_CIPHER_TKIP: 1172 return (WLAN_CIPHER_SUITE_TKIP); 1173 case IEEE80211_CIPHER_AES_CCM: 1174 return (WLAN_CIPHER_SUITE_CCMP); 1175 case IEEE80211_CIPHER_AES_CCM_256: 1176 return (WLAN_CIPHER_SUITE_CCMP_256); 1177 case IEEE80211_CIPHER_AES_GCM_128: 1178 return (WLAN_CIPHER_SUITE_GCMP); 1179 case IEEE80211_CIPHER_AES_GCM_256: 1180 return (WLAN_CIPHER_SUITE_GCMP_256); 1181 case IEEE80211_CIPHER_BIP_CMAC_128: 1182 return (WLAN_CIPHER_SUITE_AES_CMAC); 1183 case IEEE80211_CIPHER_BIP_CMAC_256: 1184 return (WLAN_CIPHER_SUITE_BIP_CMAC_256); 1185 case IEEE80211_CIPHER_BIP_GMAC_128: 1186 return (WLAN_CIPHER_SUITE_BIP_GMAC_128); 1187 case IEEE80211_CIPHER_BIP_GMAC_256: 1188 return (WLAN_CIPHER_SUITE_BIP_GMAC_256); 1189 1190 case IEEE80211_CIPHER_AES_OCB: 1191 case IEEE80211_CIPHER_TKIPMIC: 1192 /* 1193 * TKIP w/ hw MIC support 1194 * (gone wrong; should really be a crypto flag in net80211). 1195 */ 1196 case IEEE80211_CIPHER_CKIP: 1197 case IEEE80211_CIPHER_NONE: 1198 printf("%s: unsupported cipher %#010x\n", __func__, cipher); 1199 break; 1200 default: 1201 printf("%s: unknown cipher %#010x\n", __func__, cipher); 1202 }; 1203 return (0); 1204 } 1205 #endif 1206 1207 #ifdef __notyet__ 1208 static enum ieee80211_sta_state 1209 lkpi_net80211_state_to_sta_state(enum ieee80211_state state) 1210 { 1211 1212 /* 1213 * XXX-BZ The net80211 states are "try to ..", the lkpi8011 states are 1214 * "done". Also ASSOC/AUTHORIZED are both "RUN" then? 1215 */ 1216 switch (state) { 1217 case IEEE80211_S_INIT: 1218 return (IEEE80211_STA_NOTEXIST); 1219 case IEEE80211_S_SCAN: 1220 return (IEEE80211_STA_NONE); 1221 case IEEE80211_S_AUTH: 1222 return (IEEE80211_STA_AUTH); 1223 case IEEE80211_S_ASSOC: 1224 return (IEEE80211_STA_ASSOC); 1225 case IEEE80211_S_RUN: 1226 return (IEEE80211_STA_AUTHORIZED); 1227 case IEEE80211_S_CAC: 1228 case IEEE80211_S_CSA: 1229 case IEEE80211_S_SLEEP: 1230 default: 1231 UNIMPLEMENTED; 1232 }; 1233 1234 return (IEEE80211_STA_NOTEXIST); 1235 } 1236 #endif 1237 1238 static struct linuxkpi_ieee80211_channel * 1239 lkpi_find_lkpi80211_chan(struct lkpi_hw *lhw, 1240 struct ieee80211_channel *c) 1241 { 1242 struct ieee80211_hw *hw; 1243 struct linuxkpi_ieee80211_channel *channels; 1244 enum nl80211_band band; 1245 int i, nchans; 1246 1247 hw = LHW_TO_HW(lhw); 1248 band = lkpi_net80211_chan_to_nl80211_band(c); 1249 if (hw->wiphy->bands[band] == NULL) 1250 return (NULL); 1251 1252 nchans = hw->wiphy->bands[band]->n_channels; 1253 if (nchans <= 0) 1254 return (NULL); 1255 1256 channels = hw->wiphy->bands[band]->channels; 1257 for (i = 0; i < nchans; i++) { 1258 if (channels[i].center_freq == c->ic_freq) 1259 return (&channels[i]); 1260 } 1261 1262 return (NULL); 1263 } 1264 1265 #if 0 1266 static struct linuxkpi_ieee80211_channel * 1267 lkpi_get_lkpi80211_chan(struct ieee80211com *ic, struct ieee80211_node *ni) 1268 { 1269 struct linuxkpi_ieee80211_channel *chan; 1270 struct ieee80211_channel *c; 1271 struct lkpi_hw *lhw; 1272 1273 chan = NULL; 1274 if (ni != NULL && ni->ni_chan != IEEE80211_CHAN_ANYC) 1275 c = ni->ni_chan; 1276 else if (ic->ic_bsschan != IEEE80211_CHAN_ANYC) 1277 c = ic->ic_bsschan; 1278 else if (ic->ic_curchan != IEEE80211_CHAN_ANYC) 1279 c = ic->ic_curchan; 1280 else 1281 c = NULL; 1282 1283 if (c != NULL && c != IEEE80211_CHAN_ANYC) { 1284 lhw = ic->ic_softc; 1285 chan = lkpi_find_lkpi80211_chan(lhw, c); 1286 } 1287 1288 return (chan); 1289 } 1290 #endif 1291 1292 struct linuxkpi_ieee80211_channel * 1293 linuxkpi_ieee80211_get_channel(struct wiphy *wiphy, uint32_t freq) 1294 { 1295 enum nl80211_band band; 1296 1297 for (band = 0; band < NUM_NL80211_BANDS; band++) { 1298 struct ieee80211_supported_band *supband; 1299 struct linuxkpi_ieee80211_channel *channels; 1300 int i; 1301 1302 supband = wiphy->bands[band]; 1303 if (supband == NULL || supband->n_channels == 0) 1304 continue; 1305 1306 channels = supband->channels; 1307 for (i = 0; i < supband->n_channels; i++) { 1308 if (channels[i].center_freq == freq) 1309 return (&channels[i]); 1310 } 1311 } 1312 1313 return (NULL); 1314 } 1315 1316 #ifdef LKPI_80211_HW_CRYPTO 1317 static int 1318 lkpi_sta_del_keys(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1319 struct lkpi_sta *lsta) 1320 { 1321 int error; 1322 1323 if (!lkpi_hwcrypto) 1324 return (0); 1325 1326 lockdep_assert_wiphy(hw->wiphy); 1327 ieee80211_ref_node(lsta->ni); 1328 1329 error = 0; 1330 for (ieee80211_keyix keyix = 0; keyix < nitems(lsta->kc); keyix++) { 1331 struct ieee80211_key_conf *kc; 1332 int err; 1333 1334 if (lsta->kc[keyix] == NULL) 1335 continue; 1336 kc = lsta->kc[keyix]; 1337 1338 #ifdef LINUXKPI_DEBUG_80211 1339 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1340 ic_printf(lsta->ni->ni_ic, "%d %lu %s: running set_key cmd %d(%s) for " 1341 "sta %6D: keyidx %u hw_key_idx %u flags %b\n", 1342 curthread->td_tid, jiffies, __func__, 1343 DISABLE_KEY, "DISABLE", lsta->sta.addr, ":", 1344 kc->keyidx, kc->hw_key_idx, kc->flags, IEEE80211_KEY_FLAG_BITS); 1345 #endif 1346 1347 err = lkpi_80211_mo_set_key(hw, DISABLE_KEY, vif, 1348 LSTA_TO_STA(lsta), kc); 1349 if (err != 0) { 1350 ic_printf(lsta->ni->ni_ic, "%d %lu %s: set_key cmd %d(%s) for " 1351 "sta %6D failed: %d\n", curthread->td_tid, jiffies, __func__, 1352 DISABLE_KEY, "DISABLE", lsta->sta.addr, ":", err); 1353 error++; 1354 1355 /* 1356 * If we free the key here we will never be able to get it 1357 * removed from the driver/fw which will likely make us 1358 * crash (firmware). 1359 */ 1360 continue; 1361 } 1362 #ifdef LINUXKPI_DEBUG_80211 1363 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1364 ic_printf(lsta->ni->ni_ic, "%d %lu %s: set_key cmd %d(%s) for " 1365 "sta %6D succeeded: keyidx %u hw_key_idx %u flags %b\n", 1366 curthread->td_tid, jiffies, __func__, 1367 DISABLE_KEY, "DISABLE", lsta->sta.addr, ":", 1368 kc->keyidx, kc->hw_key_idx, kc->flags, IEEE80211_KEY_FLAG_BITS); 1369 #endif 1370 1371 lsta->kc[keyix] = NULL; 1372 free(kc, M_LKPI80211); 1373 } 1374 ieee80211_free_node(lsta->ni); 1375 return (error); 1376 } 1377 1378 /* XXX-BZ one day we should replace this iterating over VIFs, or node list? */ 1379 /* See also lkpi_sta_del_keys() these days. */ 1380 static int 1381 lkpi_iv_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) 1382 { 1383 struct ieee80211com *ic; 1384 struct lkpi_hw *lhw; 1385 struct ieee80211_hw *hw; 1386 struct lkpi_vif *lvif; 1387 struct lkpi_sta *lsta; 1388 struct ieee80211_vif *vif; 1389 struct ieee80211_sta *sta; 1390 struct ieee80211_node *ni; 1391 struct ieee80211_key_conf *kc; 1392 int error; 1393 1394 ic = vap->iv_ic; 1395 lhw = ic->ic_softc; 1396 hw = LHW_TO_HW(lhw); 1397 lvif = VAP_TO_LVIF(vap); 1398 vif = LVIF_TO_VIF(lvif); 1399 1400 /* 1401 * Make sure we do not make it here without going through 1402 * lkpi_iv_key_update_begin() first. 1403 */ 1404 lockdep_assert_wiphy(hw->wiphy); 1405 1406 /* 1407 * While we are assoc we may still send packets. We cannot delete the 1408 * keys as otherwise packets could go out unencrypted. Some firmware 1409 * does not like this and will fire an assert. 1410 * net80211 needs to drive this better but given we want the disassoc 1411 * frame out and have to unlock we are open to a race currently. 1412 * This check should prevent problems. 1413 * How to test: run 800Mbit/s UDP traffic and during that restart your 1414 * supplicant. You want to survive that. 1415 */ 1416 if (vif->cfg.assoc) { 1417 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1418 ic_printf(ic, "%d %lu %s: vif still assoc; not deleting keys\n", 1419 curthread->td_tid, jiffies, __func__); 1420 return (0); 1421 } 1422 1423 if (IEEE80211_KEY_UNDEFINED(k)) { 1424 ic_printf(ic, "%s: vap %p key %p is undefined: %p %u\n", 1425 __func__, vap, k, k->wk_cipher, k->wk_keyix); 1426 return (0); 1427 } 1428 1429 if (vap->iv_bss == NULL) { 1430 ic_printf(ic, "%s: iv_bss %p for vap %p is NULL\n", 1431 __func__, vap->iv_bss, vap); 1432 return (0); 1433 } 1434 1435 ni = ieee80211_ref_node(vap->iv_bss); 1436 lsta = ni->ni_drv_data; 1437 if (lsta == NULL) { 1438 ic_printf(ic, "%s: ni %p (%6D) with lsta NULL\n", 1439 __func__, ni, ni->ni_bssid, ":"); 1440 ieee80211_free_node(ni); 1441 return (0); 1442 } 1443 sta = LSTA_TO_STA(lsta); 1444 1445 if (lsta->kc[k->wk_keyix] == NULL) { 1446 #ifdef LINUXKPI_DEBUG_80211 1447 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1448 ic_printf(ic, "%d %lu %s: sta %6D and no key information, " 1449 "keyidx %u wk_macaddr %6D; returning success\n", 1450 curthread->td_tid, jiffies, __func__, sta->addr, ":", 1451 k->wk_keyix, k->wk_macaddr, ":"); 1452 #endif 1453 ieee80211_free_node(ni); 1454 return (1); 1455 } 1456 kc = lsta->kc[k->wk_keyix]; 1457 1458 #ifdef LINUXKPI_DEBUG_80211 1459 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1460 ic_printf(ic, "%d %lu %s: running set_key cmd %d(%s) for sta %6D: " 1461 "keyidx %u hw_key_idx %u flags %b\n", 1462 curthread->td_tid, jiffies, __func__, 1463 DISABLE_KEY, "DISABLE", sta->addr, ":", 1464 kc->keyidx, kc->hw_key_idx, kc->flags, IEEE80211_KEY_FLAG_BITS); 1465 #endif 1466 1467 error = lkpi_80211_mo_set_key(hw, DISABLE_KEY, vif, sta, kc); 1468 if (error != 0) { 1469 ic_printf(ic, "%d %lu %s: set_key cmd %d(%s) for sta %6D failed: %d\n", 1470 curthread->td_tid, jiffies, __func__, 1471 DISABLE_KEY, "DISABLE", sta->addr, ":", error); 1472 error = 0; 1473 goto out; 1474 } 1475 1476 #ifdef LINUXKPI_DEBUG_80211 1477 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1478 ic_printf(ic, "%d %lu %s: set_key cmd %d(%s) for sta %6D succeeded: " 1479 "keyidx %u hw_key_idx %u flags %b\n", 1480 curthread->td_tid, jiffies, __func__, 1481 DISABLE_KEY, "DISABLE", sta->addr, ":", 1482 kc->keyidx, kc->hw_key_idx, kc->flags, IEEE80211_KEY_FLAG_BITS); 1483 #endif 1484 lsta->kc[k->wk_keyix] = NULL; 1485 free(kc, M_LKPI80211); 1486 error = 1; 1487 out: 1488 ieee80211_free_node(ni); 1489 return (error); 1490 } 1491 1492 static int 1493 lkpi_iv_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k) 1494 { 1495 struct ieee80211com *ic; 1496 struct lkpi_hw *lhw; 1497 struct ieee80211_hw *hw; 1498 struct lkpi_vif *lvif; 1499 struct lkpi_sta *lsta; 1500 struct ieee80211_vif *vif; 1501 struct ieee80211_sta *sta; 1502 struct ieee80211_node *ni; 1503 struct ieee80211_key_conf *kc; 1504 uint32_t lcipher; 1505 uint16_t exp_flags; 1506 uint8_t keylen; 1507 int error; 1508 1509 ic = vap->iv_ic; 1510 lhw = ic->ic_softc; 1511 hw = LHW_TO_HW(lhw); 1512 1513 /* 1514 * Make sure we do not make it here without going through 1515 * lkpi_iv_key_update_begin() first. 1516 */ 1517 lockdep_assert_wiphy(hw->wiphy); 1518 1519 if (IEEE80211_KEY_UNDEFINED(k)) { 1520 ic_printf(ic, "%s: vap %p key %p is undefined: %p %u\n", 1521 __func__, vap, k, k->wk_cipher, k->wk_keyix); 1522 return (0); 1523 } 1524 1525 if (vap->iv_bss == NULL) { 1526 ic_printf(ic, "%s: iv_bss %p for vap %p is NULL\n", 1527 __func__, vap->iv_bss, vap); 1528 return (0); 1529 } 1530 ni = ieee80211_ref_node(vap->iv_bss); 1531 lsta = ni->ni_drv_data; 1532 if (lsta == NULL) { 1533 ic_printf(ic, "%s: ni %p (%6D) with lsta NULL\n", 1534 __func__, ni, ni->ni_bssid, ":"); 1535 ieee80211_free_node(ni); 1536 return (0); 1537 } 1538 sta = LSTA_TO_STA(lsta); 1539 1540 keylen = k->wk_keylen; 1541 lcipher = lkpi_net80211_to_l80211_cipher_suite( 1542 k->wk_cipher->ic_cipher, k->wk_keylen); 1543 switch (lcipher) { 1544 case WLAN_CIPHER_SUITE_TKIP: 1545 keylen += 2 * k->wk_cipher->ic_miclen; 1546 break; 1547 case WLAN_CIPHER_SUITE_CCMP: 1548 case WLAN_CIPHER_SUITE_GCMP: 1549 break; 1550 default: 1551 ic_printf(ic, "%s: CIPHER SUITE %#x (%s) not supported\n", 1552 __func__, lcipher, lkpi_cipher_suite_to_name(lcipher)); 1553 IMPROVE(); 1554 ieee80211_free_node(ni); 1555 return (0); 1556 } 1557 1558 if (lsta->kc[k->wk_keyix] != NULL) { 1559 IMPROVE("Still in firmware? Del first. Can we assert this cannot happen?"); 1560 ic_printf(ic, "%s: sta %6D found with key information\n", 1561 __func__, sta->addr, ":"); 1562 kc = lsta->kc[k->wk_keyix]; 1563 lsta->kc[k->wk_keyix] = NULL; 1564 free(kc, M_LKPI80211); 1565 kc = NULL; /* safeguard */ 1566 } 1567 1568 kc = malloc(sizeof(*kc) + keylen, M_LKPI80211, M_WAITOK | M_ZERO); 1569 kc->_k = k; /* Save the pointer to net80211. */ 1570 kc->cipher = lcipher; 1571 kc->keyidx = k->wk_keyix; 1572 #if 0 1573 kc->hw_key_idx = /* set by hw and needs to be passed for TX */; 1574 #endif 1575 atomic64_set(&kc->tx_pn, k->wk_keytsc); 1576 kc->keylen = k->wk_keylen; 1577 memcpy(kc->key, k->wk_key, k->wk_keylen); 1578 1579 if (k->wk_flags & (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)) 1580 kc->flags |= IEEE80211_KEY_FLAG_PAIRWISE; 1581 if (k->wk_flags & IEEE80211_KEY_GROUP) 1582 kc->flags &= ~IEEE80211_KEY_FLAG_PAIRWISE; 1583 1584 kc->iv_len = k->wk_cipher->ic_header; 1585 kc->icv_len = k->wk_cipher->ic_trailer; 1586 1587 switch (kc->cipher) { 1588 case WLAN_CIPHER_SUITE_TKIP: 1589 memcpy(kc->key + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY, k->wk_txmic, k->wk_cipher->ic_miclen); 1590 memcpy(kc->key + NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY, k->wk_rxmic, k->wk_cipher->ic_miclen); 1591 break; 1592 case WLAN_CIPHER_SUITE_CCMP: 1593 case WLAN_CIPHER_SUITE_GCMP: 1594 break; 1595 default: 1596 /* currently UNREACH */ 1597 IMPROVE(); 1598 break; 1599 }; 1600 lsta->kc[k->wk_keyix] = kc; 1601 1602 #ifdef LINUXKPI_DEBUG_80211 1603 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1604 ic_printf(ic, "%d %lu %s: running set_key cmd %d(%s) for sta %6D: " 1605 "kc %p keyidx %u hw_key_idx %u keylen %u flags %b\n", 1606 curthread->td_tid, jiffies, __func__, 1607 SET_KEY, "SET", sta->addr, ":", kc, kc->keyidx, kc->hw_key_idx, 1608 kc->keylen, kc->flags, IEEE80211_KEY_FLAG_BITS); 1609 #endif 1610 1611 lvif = VAP_TO_LVIF(vap); 1612 vif = LVIF_TO_VIF(lvif); 1613 error = lkpi_80211_mo_set_key(hw, SET_KEY, vif, sta, kc); 1614 if (error != 0) { 1615 ic_printf(ic, "%d %lu %s: set_key cmd %d(%s) for sta %6D failed: %d\n", 1616 curthread->td_tid, jiffies, __func__, 1617 SET_KEY, "SET", sta->addr, ":", error); 1618 lsta->kc[k->wk_keyix] = NULL; 1619 free(kc, M_LKPI80211); 1620 ieee80211_free_node(ni); 1621 return (0); 1622 } 1623 1624 #ifdef LINUXKPI_DEBUG_80211 1625 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1626 ic_printf(ic, "%d %lu %s: set_key cmd %d(%s) for sta %6D succeeded: " 1627 "kc %p keyidx %u hw_key_idx %u flags %b\n", 1628 curthread->td_tid, jiffies, __func__, 1629 SET_KEY, "SET", sta->addr, ":", 1630 kc, kc->keyidx, kc->hw_key_idx, kc->flags, IEEE80211_KEY_FLAG_BITS); 1631 #endif 1632 1633 exp_flags = 0; 1634 switch (kc->cipher) { 1635 case WLAN_CIPHER_SUITE_TKIP: 1636 exp_flags = (IEEE80211_KEY_FLAG_PAIRWISE | 1637 IEEE80211_KEY_FLAG_PUT_IV_SPACE | 1638 IEEE80211_KEY_FLAG_GENERATE_MMIC | 1639 IEEE80211_KEY_FLAG_PUT_MIC_SPACE); 1640 #define TKIP_INVAL_COMBINATION \ 1641 (IEEE80211_KEY_FLAG_PUT_MIC_SPACE|IEEE80211_KEY_FLAG_GENERATE_MMIC) 1642 if ((kc->flags & TKIP_INVAL_COMBINATION) == TKIP_INVAL_COMBINATION) { 1643 ic_printf(ic, "%s: SET_KEY for %s returned invalid " 1644 "combination %b\n", __func__, 1645 lkpi_cipher_suite_to_name(kc->cipher), 1646 kc->flags, IEEE80211_KEY_FLAG_BITS); 1647 } 1648 #undef TKIP_INVAL_COMBINATION 1649 #ifdef __notyet__ 1650 /* Do flags surgery; special see linuxkpi_ieee80211_ifattach(). */ 1651 if ((kc->flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) != 0) { 1652 k->wk_flags &= ~(IEEE80211_KEY_NOMICMGT|IEEE80211_KEY_NOMIC); 1653 k->wk_flags |= IEEE80211_KEY_SWMIC; 1654 ic->ic_cryptocaps &= ~IEEE80211_CRYPTO_TKIPMIC 1655 } 1656 #endif 1657 break; 1658 case WLAN_CIPHER_SUITE_CCMP: 1659 case WLAN_CIPHER_SUITE_GCMP: 1660 exp_flags = (IEEE80211_KEY_FLAG_PAIRWISE | 1661 IEEE80211_KEY_FLAG_PUT_IV_SPACE | 1662 IEEE80211_KEY_FLAG_GENERATE_IV | 1663 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT | /* Only needs IV geeration for MGMT frames. */ 1664 IEEE80211_KEY_FLAG_SW_MGMT_TX); /* MFP in software */ 1665 break; 1666 } 1667 if ((kc->flags & ~exp_flags) != 0) 1668 ic_printf(ic, "%s: SET_KEY for %s returned unexpected key flags: " 1669 " %#06x & ~%#06x = %b\n", __func__, 1670 lkpi_cipher_suite_to_name(kc->cipher), kc->flags, exp_flags, 1671 (kc->flags & ~exp_flags), IEEE80211_KEY_FLAG_BITS); 1672 1673 #ifdef __notyet__ 1674 /* Do flags surgery. */ 1675 if ((kc->flags & IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) == 0) 1676 k->wk_flags |= IEEE80211_KEY_NOIVMGT; 1677 if ((kc->flags & IEEE80211_KEY_FLAG_GENERATE_IV) == 0) 1678 k->wk_flags |= IEEE80211_KEY_NOIV; 1679 #endif 1680 1681 ieee80211_free_node(ni); 1682 return (1); 1683 } 1684 1685 static void 1686 lkpi_iv_key_update_begin(struct ieee80211vap *vap) 1687 { 1688 struct ieee80211_node_table *nt; 1689 struct ieee80211com *ic; 1690 struct lkpi_hw *lhw; 1691 struct ieee80211_hw *hw; 1692 struct lkpi_vif *lvif; 1693 struct ieee80211_node *ni; 1694 bool icislocked, ntislocked; 1695 1696 ic = vap->iv_ic; 1697 lhw = ic->ic_softc; 1698 hw = LHW_TO_HW(lhw); 1699 lvif = VAP_TO_LVIF(vap); 1700 nt = &ic->ic_sta; 1701 1702 icislocked = IEEE80211_IS_LOCKED(ic); 1703 ntislocked = IEEE80211_NODE_IS_LOCKED(nt); 1704 1705 #ifdef LINUXKPI_DEBUG_80211 1706 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1707 ic_printf(ic, "%d %lu %s: vap %p ic %p %slocked nt %p %slocked " 1708 "lvif ic_unlocked %d nt_unlocked %d\n", 1709 curthread->td_tid, jiffies, __func__, vap, 1710 ic, icislocked ? "" : "un", nt, ntislocked ? "" : "un", 1711 lvif->ic_unlocked, lvif->nt_unlocked); 1712 #endif 1713 1714 /* 1715 * This is inconsistent net80211 locking to be fixed one day. 1716 */ 1717 /* Try to make sure the node does not go away while possibly unlocked. */ 1718 ni = NULL; 1719 if (icislocked || ntislocked) { 1720 if (vap->iv_bss != NULL) 1721 ni = ieee80211_ref_node(vap->iv_bss); 1722 } 1723 1724 if (icislocked) 1725 IEEE80211_UNLOCK(ic); 1726 if (ntislocked) 1727 IEEE80211_NODE_UNLOCK(nt); 1728 1729 wiphy_lock(hw->wiphy); 1730 1731 KASSERT(lvif->key_update_iv_bss == NULL, ("%s: key_update_iv_bss not NULL %p", 1732 __func__, lvif->key_update_iv_bss)); 1733 lvif->key_update_iv_bss = ni; 1734 1735 /* 1736 * ic/nt_unlocked could be a bool given we are under the lock and there 1737 * must only be a single thread. 1738 * In case anything in the future disturbs the order the refcnt will 1739 * help us catching problems a lot easier. 1740 */ 1741 if (icislocked) 1742 refcount_acquire(&lvif->ic_unlocked); 1743 if (ntislocked) 1744 refcount_acquire(&lvif->nt_unlocked); 1745 1746 /* 1747 * Stop the queues while doing key updates. 1748 */ 1749 ieee80211_stop_queues(hw); 1750 } 1751 1752 static void 1753 lkpi_iv_key_update_end(struct ieee80211vap *vap) 1754 { 1755 struct ieee80211_node_table *nt; 1756 struct ieee80211com *ic; 1757 struct lkpi_hw *lhw; 1758 struct ieee80211_hw *hw; 1759 struct lkpi_vif *lvif; 1760 bool icislocked, ntislocked; 1761 1762 ic = vap->iv_ic; 1763 lhw = ic->ic_softc; 1764 hw = LHW_TO_HW(lhw); 1765 lvif = VAP_TO_LVIF(vap); 1766 nt = &ic->ic_sta; 1767 1768 /* 1769 * Re-enabled the queues after the key update. 1770 */ 1771 lkpi_ieee80211_wake_queues_locked(hw); 1772 1773 icislocked = IEEE80211_IS_LOCKED(ic); 1774 MPASS(!icislocked); 1775 ntislocked = IEEE80211_NODE_IS_LOCKED(nt); 1776 MPASS(!ntislocked); 1777 1778 #ifdef LINUXKPI_DEBUG_80211 1779 if (linuxkpi_debug_80211 & D80211_TRACE_HW_CRYPTO) 1780 ic_printf(ic, "%d %lu %s: vap %p ic %p %slocked nt %p %slocked " 1781 "lvif ic_unlocked %d nt_unlocked %d\n", 1782 curthread->td_tid, jiffies, __func__, vap, 1783 ic, icislocked ? "" : "un", nt, ntislocked ? "" : "un", 1784 lvif->ic_unlocked, lvif->nt_unlocked); 1785 #endif 1786 1787 /* 1788 * Check under lock; see comment in lkpi_iv_key_update_begin(). 1789 * In case the refcnt gets out of sync locking in net80211 will 1790 * quickly barf as well (trying to unlock a lock not held). 1791 */ 1792 icislocked = refcount_release_if_last(&lvif->ic_unlocked); 1793 ntislocked = refcount_release_if_last(&lvif->nt_unlocked); 1794 1795 if (lvif->key_update_iv_bss != NULL) { 1796 ieee80211_free_node(lvif->key_update_iv_bss); 1797 lvif->key_update_iv_bss = NULL; 1798 } 1799 1800 wiphy_unlock(hw->wiphy); 1801 1802 /* 1803 * This is inconsistent net80211 locking to be fixed one day. 1804 * ic before nt to avoid a LOR. 1805 */ 1806 if (icislocked) 1807 IEEE80211_LOCK(ic); 1808 if (ntislocked) 1809 IEEE80211_NODE_LOCK(nt); 1810 } 1811 #endif 1812 1813 static void 1814 lkpi_cleanup_mcast_list_locked(struct lkpi_hw *lhw) 1815 { 1816 struct list_head *le, *next; 1817 struct netdev_hw_addr *addr; 1818 1819 if (lhw->mc_list.count != 0) { 1820 list_for_each_safe(le, next, &lhw->mc_list.addr_list) { 1821 addr = list_entry(le, struct netdev_hw_addr, addr_list); 1822 list_del(le); 1823 lhw->mc_list.count--; 1824 free(addr, M_LKPI80211); 1825 } 1826 } 1827 KASSERT(lhw->mc_list.count == 0, ("%s: mc_list %p count %d != 0\n", 1828 __func__, &lhw->mc_list, lhw->mc_list.count)); 1829 } 1830 1831 static u_int 1832 lkpi_ic_update_mcast_copy(void *arg, struct sockaddr_dl *sdl, u_int cnt) 1833 { 1834 struct netdev_hw_addr_list *mc_list; 1835 struct netdev_hw_addr *addr; 1836 1837 KASSERT(arg != NULL && sdl != NULL, ("%s: arg %p sdl %p cnt %u\n", 1838 __func__, arg, sdl, cnt)); 1839 1840 mc_list = arg; 1841 /* If it is on the list already skip it. */ 1842 netdev_hw_addr_list_for_each(addr, mc_list) { 1843 if (!memcmp(addr->addr, LLADDR(sdl), sdl->sdl_alen)) 1844 return (0); 1845 } 1846 1847 addr = malloc(sizeof(*addr), M_LKPI80211, M_NOWAIT | M_ZERO); 1848 if (addr == NULL) 1849 return (0); 1850 1851 INIT_LIST_HEAD(&addr->addr_list); 1852 memcpy(addr->addr, LLADDR(sdl), sdl->sdl_alen); 1853 /* XXX this should be a netdev function? */ 1854 list_add(&addr->addr_list, &mc_list->addr_list); 1855 mc_list->count++; 1856 1857 #ifdef LINUXKPI_DEBUG_80211 1858 if (linuxkpi_debug_80211 & D80211_TRACE) 1859 printf("%s:%d: mc_list count %d: added %6D\n", 1860 __func__, __LINE__, mc_list->count, addr->addr, ":"); 1861 #endif 1862 1863 return (1); 1864 } 1865 1866 static void 1867 lkpi_update_mcast_filter(struct ieee80211com *ic) 1868 { 1869 struct lkpi_hw *lhw; 1870 struct ieee80211_hw *hw; 1871 u64 mc; 1872 unsigned int changed_flags, flags; 1873 bool scanning; 1874 1875 lhw = ic->ic_softc; 1876 1877 if (lhw->ops->prepare_multicast == NULL || 1878 lhw->ops->configure_filter == NULL) 1879 return; 1880 1881 LKPI_80211_LHW_SCAN_LOCK(lhw); 1882 scanning = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0; 1883 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 1884 1885 LKPI_80211_LHW_MC_LOCK(lhw); 1886 1887 flags = 0; 1888 if (scanning) 1889 flags |= FIF_BCN_PRBRESP_PROMISC; 1890 if (lhw->mc_all_multi) 1891 flags |= FIF_ALLMULTI; 1892 1893 hw = LHW_TO_HW(lhw); 1894 mc = lkpi_80211_mo_prepare_multicast(hw, &lhw->mc_list); 1895 1896 changed_flags = (lhw->mc_flags ^ flags) & FIF_FLAGS_MASK; 1897 lkpi_80211_mo_configure_filter(hw, changed_flags, &flags, mc); 1898 lhw->mc_flags = flags; 1899 1900 #ifdef LINUXKPI_DEBUG_80211 1901 if (linuxkpi_debug_80211 & D80211_TRACE) 1902 printf("%s: changed_flags %#06x count %d mc_flags %#010x\n", 1903 __func__, changed_flags, lhw->mc_list.count, lhw->mc_flags); 1904 #endif 1905 1906 LKPI_80211_LHW_MC_UNLOCK(lhw); 1907 } 1908 1909 static enum ieee80211_bss_changed 1910 lkpi_update_dtim_tsf(struct ieee80211_vif *vif, struct ieee80211_node *ni, 1911 struct ieee80211vap *vap, const char *_f, int _l) 1912 { 1913 enum ieee80211_bss_changed bss_changed; 1914 1915 bss_changed = 0; 1916 1917 #ifdef LINUXKPI_DEBUG_80211 1918 if (linuxkpi_debug_80211 & D80211_TRACE) 1919 printf("%s:%d [%s:%d] assoc %d aid %d beacon_int %u " 1920 "dtim_period %u sync_dtim_count %u sync_tsf %ju " 1921 "sync_device_ts %u bss_changed %#010jx\n", 1922 __func__, __LINE__, _f, _l, 1923 vif->cfg.assoc, vif->cfg.aid, 1924 vif->bss_conf.beacon_int, vif->bss_conf.dtim_period, 1925 vif->bss_conf.sync_dtim_count, 1926 (uintmax_t)vif->bss_conf.sync_tsf, 1927 vif->bss_conf.sync_device_ts, 1928 (uintmax_t)bss_changed); 1929 #endif 1930 1931 if (vif->bss_conf.beacon_int != ni->ni_intval) { 1932 vif->bss_conf.beacon_int = ni->ni_intval; 1933 /* iwlwifi FW bug workaround; iwl_mvm_mac_sta_state. */ 1934 if (vif->bss_conf.beacon_int < 16) 1935 vif->bss_conf.beacon_int = 16; 1936 bss_changed |= BSS_CHANGED_BEACON_INT; 1937 } 1938 1939 /* 1940 * lkpi_iv_sta_recv_mgmt() will directly call into this function. 1941 * iwlwifi(4) in iwl_mvm_bss_info_changed_station_common() will 1942 * stop seesion protection the moment it sees 1943 * BSS_CHANGED_BEACON_INFO (with the expectations that it was 1944 * "a beacon from the associated AP"). It will also update 1945 * the beacon filter in that case. This is the only place 1946 * we set the BSS_CHANGED_BEACON_INFO on the non-teardown 1947 * path so make sure we only do run this check once we are 1948 * assoc. (*iv_recv_mgmt)() will be called before we enter 1949 * here so the ni will be updates with information from the 1950 * beacon via net80211::sta_recv_mgmt(). We also need to 1951 * make sure we do not do it on every beacon we still may 1952 * get so only do if something changed. vif->bss_conf.dtim_period 1953 * should be 0 as we start up (we also reset it on teardown). 1954 */ 1955 if (vif->cfg.assoc && 1956 vif->bss_conf.dtim_period != ni->ni_dtim_period && 1957 ni->ni_dtim_period > 0) { 1958 vif->bss_conf.dtim_period = ni->ni_dtim_period; 1959 bss_changed |= BSS_CHANGED_BEACON_INFO; 1960 } 1961 1962 vif->bss_conf.sync_dtim_count = ni->ni_dtim_count; 1963 vif->bss_conf.sync_tsf = le64toh(ni->ni_tstamp.tsf); 1964 /* vif->bss_conf.sync_device_ts = set in linuxkpi_ieee80211_rx. */ 1965 1966 #ifdef LINUXKPI_DEBUG_80211 1967 if (linuxkpi_debug_80211 & D80211_TRACE) 1968 printf("%s:%d [%s:%d] assoc %d aid %d beacon_int %u " 1969 "dtim_period %u sync_dtim_count %u sync_tsf %ju " 1970 "sync_device_ts %u bss_changed %#010jx\n", 1971 __func__, __LINE__, _f, _l, 1972 vif->cfg.assoc, vif->cfg.aid, 1973 vif->bss_conf.beacon_int, vif->bss_conf.dtim_period, 1974 vif->bss_conf.sync_dtim_count, 1975 (uintmax_t)vif->bss_conf.sync_tsf, 1976 vif->bss_conf.sync_device_ts, 1977 (uintmax_t)bss_changed); 1978 #endif 1979 1980 return (bss_changed); 1981 } 1982 1983 static void 1984 lkpi_stop_hw_scan(struct lkpi_hw *lhw, struct ieee80211_vif *vif) 1985 { 1986 struct ieee80211_hw *hw; 1987 int error; 1988 bool cancel; 1989 1990 TRACE_SCAN(lhw->ic, "scan_flags %b", lhw->scan_flags, LKPI_LHW_SCAN_BITS); 1991 1992 LKPI_80211_LHW_SCAN_LOCK(lhw); 1993 cancel = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0; 1994 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 1995 if (!cancel) 1996 return; 1997 1998 hw = LHW_TO_HW(lhw); 1999 2000 IEEE80211_UNLOCK(lhw->ic); 2001 wiphy_lock(hw->wiphy); 2002 /* Need to cancel the scan. */ 2003 lkpi_80211_mo_cancel_hw_scan(hw, vif); 2004 wiphy_unlock(hw->wiphy); 2005 2006 /* Need to make sure we see ieee80211_scan_completed. */ 2007 LKPI_80211_LHW_SCAN_LOCK(lhw); 2008 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0) 2009 error = msleep(lhw, &lhw->scan_mtx, 0, "lhwscanstop", hz/2); 2010 cancel = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0; 2011 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 2012 2013 IEEE80211_LOCK(lhw->ic); 2014 2015 if (cancel) 2016 ic_printf(lhw->ic, "%s: failed to cancel scan: %d (%p, %p)\n", 2017 __func__, error, lhw, vif); 2018 } 2019 2020 static void 2021 lkpi_hw_conf_idle(struct ieee80211_hw *hw, bool new) 2022 { 2023 struct lkpi_hw *lhw; 2024 int error; 2025 bool old; 2026 2027 old = hw->conf.flags & IEEE80211_CONF_IDLE; 2028 if (old == new) 2029 return; 2030 2031 hw->conf.flags ^= IEEE80211_CONF_IDLE; 2032 error = lkpi_80211_mo_config(hw, IEEE80211_CONF_CHANGE_IDLE); 2033 if (error != 0 && error != EOPNOTSUPP) { 2034 lhw = HW_TO_LHW(hw); 2035 ic_printf(lhw->ic, "ERROR: %s: config %#0x returned %d\n", 2036 __func__, IEEE80211_CONF_CHANGE_IDLE, error); 2037 } 2038 } 2039 2040 static enum ieee80211_bss_changed 2041 lkpi_disassoc(struct ieee80211_sta *sta, struct ieee80211_vif *vif, 2042 struct lkpi_hw *lhw) 2043 { 2044 enum ieee80211_bss_changed changed; 2045 struct lkpi_vif *lvif; 2046 2047 changed = 0; 2048 sta->aid = 0; 2049 if (vif->cfg.assoc) { 2050 2051 vif->cfg.assoc = false; 2052 vif->cfg.aid = 0; 2053 changed |= BSS_CHANGED_ASSOC; 2054 IMPROVE(); 2055 2056 lkpi_update_mcast_filter(lhw->ic); 2057 2058 /* 2059 * Executing the bss_info_changed(BSS_CHANGED_ASSOC) with 2060 * assoc = false right away here will remove the sta from 2061 * firmware for iwlwifi. 2062 * We no longer do this but only return the BSS_CHNAGED value. 2063 * The caller is responsible for removing the sta gong to 2064 * IEEE80211_STA_NOTEXIST and then executing the 2065 * bss_info_changed() update. 2066 * See lkpi_sta_run_to_init() for more detailed comment. 2067 */ 2068 2069 lvif = VIF_TO_LVIF(vif); 2070 lvif->beacons = 0; 2071 } 2072 2073 return (changed); 2074 } 2075 2076 static void 2077 lkpi_wake_tx_queues(struct ieee80211_hw *hw, struct ieee80211_sta *sta, 2078 bool dequeue_seen, bool no_emptyq) 2079 { 2080 struct lkpi_txq *ltxq; 2081 int tid; 2082 bool ltxq_empty; 2083 2084 /* Wake up all queues to know they are allocated in the driver. */ 2085 for (tid = 0; tid < nitems(sta->txq); tid++) { 2086 2087 if (tid == IEEE80211_NUM_TIDS) { 2088 IMPROVE("station specific?"); 2089 if (!ieee80211_hw_check(hw, STA_MMPDU_TXQ)) 2090 continue; 2091 } else if (tid >= hw->queues) 2092 continue; 2093 2094 if (sta->txq[tid] == NULL) 2095 continue; 2096 2097 ltxq = TXQ_TO_LTXQ(sta->txq[tid]); 2098 if (dequeue_seen && !ltxq->seen_dequeue) 2099 continue; 2100 2101 LKPI_80211_LTXQ_LOCK(ltxq); 2102 ltxq_empty = skb_queue_empty(<xq->skbq); 2103 LKPI_80211_LTXQ_UNLOCK(ltxq); 2104 if (no_emptyq && ltxq_empty) 2105 continue; 2106 2107 lkpi_80211_mo_wake_tx_queue(hw, sta->txq[tid]); 2108 } 2109 } 2110 2111 /* 2112 * On the way down from RUN -> ASSOC -> AUTH we may send a DISASSOC or DEAUTH 2113 * packet. The problem is that the state machine functions tend to hold the 2114 * LHW lock which will prevent lkpi_80211_txq_tx_one() from sending the packet. 2115 * We call this after dropping the ic lock and before acquiring the LHW lock. 2116 * we make sure no further packets are queued and if they are queued the task 2117 * will finish or be cancelled. At the end if a packet is left we manually 2118 * send it. scan_to_auth() would re-enable sending if the lsta would be 2119 * re-used. 2120 */ 2121 static void 2122 lkpi_80211_flush_tx(struct lkpi_hw *lhw, struct lkpi_sta *lsta) 2123 { 2124 struct ieee80211_hw *hw; 2125 struct mbufq mq; 2126 struct mbuf *m; 2127 int len; 2128 2129 /* There is no lockdep_assert_not_held_wiphy(). */ 2130 hw = LHW_TO_HW(lhw); 2131 lockdep_assert_not_held(&hw->wiphy->mtx); 2132 2133 /* Do not accept any new packets until scan_to_auth or lsta_free(). */ 2134 LKPI_80211_LSTA_TXQ_LOCK(lsta); 2135 lsta->txq_ready = false; 2136 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 2137 2138 while (taskqueue_cancel(taskqueue_thread, &lsta->txq_task, NULL) != 0) 2139 taskqueue_drain(taskqueue_thread, &lsta->txq_task); 2140 2141 LKPI_80211_LSTA_TXQ_LOCK(lsta); 2142 len = mbufq_len(&lsta->txq); 2143 if (len <= 0) { 2144 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 2145 return; 2146 } 2147 2148 mbufq_init(&mq, IFQ_MAXLEN); 2149 mbufq_concat(&mq, &lsta->txq); 2150 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 2151 2152 m = mbufq_dequeue(&mq); 2153 while (m != NULL) { 2154 lkpi_80211_txq_tx_one(lsta, m); 2155 m = mbufq_dequeue(&mq); 2156 } 2157 } 2158 2159 2160 static void 2161 lkpi_remove_chanctx(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 2162 { 2163 struct ieee80211_chanctx_conf *chanctx_conf; 2164 struct lkpi_chanctx *lchanctx; 2165 2166 chanctx_conf = rcu_dereference_protected(vif->bss_conf.chanctx_conf, 2167 lockdep_is_held(&hw->wiphy->mtx)); 2168 2169 if (chanctx_conf == NULL) 2170 return; 2171 2172 /* Remove vif context. */ 2173 lkpi_80211_mo_unassign_vif_chanctx(hw, vif, &vif->bss_conf, chanctx_conf); 2174 2175 lkpi_hw_conf_idle(hw, true); 2176 2177 /* Remove chan ctx. */ 2178 lkpi_80211_mo_remove_chanctx(hw, chanctx_conf); 2179 2180 /* Cleanup. */ 2181 rcu_assign_pointer(vif->bss_conf.chanctx_conf, NULL); 2182 lchanctx = CHANCTX_CONF_TO_LCHANCTX(chanctx_conf); 2183 list_del(&lchanctx->entry); 2184 free(lchanctx, M_LKPI80211); 2185 } 2186 2187 2188 /* -------------------------------------------------------------------------- */ 2189 2190 static int 2191 lkpi_sta_state_do_nada(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2192 { 2193 2194 return (0); 2195 } 2196 2197 /* lkpi_iv_newstate() handles the stop scan case generally. */ 2198 #define lkpi_sta_scan_to_init(_v, _n, _a) lkpi_sta_state_do_nada(_v, _n, _a) 2199 2200 static int 2201 lkpi_sta_scan_to_auth(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2202 { 2203 struct linuxkpi_ieee80211_channel *chan; 2204 struct lkpi_chanctx *lchanctx; 2205 struct ieee80211_chanctx_conf *chanctx_conf; 2206 struct lkpi_hw *lhw; 2207 struct ieee80211_hw *hw; 2208 struct lkpi_vif *lvif; 2209 struct ieee80211_vif *vif; 2210 struct ieee80211_node *ni; 2211 struct lkpi_sta *lsta; 2212 enum ieee80211_bss_changed bss_changed; 2213 struct ieee80211_prep_tx_info prep_tx_info; 2214 uint32_t changed; 2215 int error; 2216 bool synched; 2217 2218 /* 2219 * In here we use vap->iv_bss until lvif->lvif_bss is set. 2220 * For all later (STATE >= AUTH) functions we need to use the lvif 2221 * cache which will be tracked even through (*iv_update_bss)(). 2222 */ 2223 2224 if (vap->iv_bss == NULL) { 2225 ic_printf(vap->iv_ic, "%s: no iv_bss for vap %p\n", __func__, vap); 2226 return (EINVAL); 2227 } 2228 /* 2229 * Keep the ni alive locally. In theory (and practice) iv_bss can change 2230 * once we unlock here. This is due to net80211 allowing state changes 2231 * and new join1() despite having an active node as well as due to 2232 * the fact that the iv_bss can be swapped under the hood in (*iv_update_bss). 2233 */ 2234 ni = ieee80211_ref_node(vap->iv_bss); 2235 if (ni->ni_chan == NULL || ni->ni_chan == IEEE80211_CHAN_ANYC) { 2236 ic_printf(vap->iv_ic, "%s: no channel set for iv_bss ni %p " 2237 "on vap %p\n", __func__, ni, vap); 2238 ieee80211_free_node(ni); /* Error handling for the local ni. */ 2239 return (EINVAL); 2240 } 2241 2242 lhw = vap->iv_ic->ic_softc; 2243 chan = lkpi_find_lkpi80211_chan(lhw, ni->ni_chan); 2244 if (chan == NULL) { 2245 ic_printf(vap->iv_ic, "%s: failed to get LKPI channel from " 2246 "iv_bss ni %p on vap %p\n", __func__, ni, vap); 2247 ieee80211_free_node(ni); /* Error handling for the local ni. */ 2248 return (ESRCH); 2249 } 2250 2251 hw = LHW_TO_HW(lhw); 2252 lvif = VAP_TO_LVIF(vap); 2253 vif = LVIF_TO_VIF(lvif); 2254 2255 LKPI_80211_LVIF_LOCK(lvif); 2256 /* XXX-BZ KASSERT later? */ 2257 if (lvif->lvif_bss_synched || lvif->lvif_bss != NULL) { 2258 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 2259 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 2260 lvif, vap, vap->iv_bss, lvif->lvif_bss, 2261 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 2262 lvif->lvif_bss_synched); 2263 LKPI_80211_LVIF_UNLOCK(lvif); 2264 ieee80211_free_node(ni); /* Error handling for the local ni. */ 2265 return (EBUSY); 2266 } 2267 LKPI_80211_LVIF_UNLOCK(lvif); 2268 2269 IEEE80211_UNLOCK(vap->iv_ic); 2270 wiphy_lock(hw->wiphy); 2271 2272 /* Add chanctx (or if exists, change it). */ 2273 chanctx_conf = rcu_dereference_protected(vif->bss_conf.chanctx_conf, 2274 lockdep_is_held(&hw->wiphy->mtx)); 2275 if (chanctx_conf != NULL) { 2276 lchanctx = CHANCTX_CONF_TO_LCHANCTX(chanctx_conf); 2277 IMPROVE("diff changes for changed, working on live copy, rcu"); 2278 } else { 2279 /* Keep separate alloc as in Linux this is rcu managed? */ 2280 lchanctx = malloc(sizeof(*lchanctx) + hw->chanctx_data_size, 2281 M_LKPI80211, M_WAITOK | M_ZERO); 2282 chanctx_conf = &lchanctx->chanctx_conf; 2283 } 2284 2285 chanctx_conf->rx_chains_static = 1; 2286 chanctx_conf->rx_chains_dynamic = 1; 2287 chanctx_conf->radar_enabled = 2288 (chan->flags & IEEE80211_CHAN_RADAR) ? true : false; 2289 chanctx_conf->def.chan = chan; 2290 chanctx_conf->def.width = NL80211_CHAN_WIDTH_20_NOHT; 2291 chanctx_conf->def.center_freq1 = ieee80211_get_channel_center_freq1(ni->ni_chan); 2292 chanctx_conf->def.center_freq2 = ieee80211_get_channel_center_freq2(ni->ni_chan); 2293 IMPROVE("Check vht_cap from band not just chan?"); 2294 KASSERT(ni->ni_chan != NULL && ni->ni_chan != IEEE80211_CHAN_ANYC, 2295 ("%s:%d: ni %p ni_chan %p\n", __func__, __LINE__, ni, ni->ni_chan)); 2296 2297 #ifdef LKPI_80211_HT 2298 if (IEEE80211_IS_CHAN_HT(ni->ni_chan)) { 2299 if (IEEE80211_IS_CHAN_HT40(ni->ni_chan)) 2300 chanctx_conf->def.width = NL80211_CHAN_WIDTH_40; 2301 else 2302 chanctx_conf->def.width = NL80211_CHAN_WIDTH_20; 2303 } 2304 #endif 2305 #ifdef LKPI_80211_VHT 2306 if (IEEE80211_IS_CHAN_VHT_5GHZ(ni->ni_chan)) { 2307 if (IEEE80211_IS_CHAN_VHT80P80(ni->ni_chan)) 2308 chanctx_conf->def.width = NL80211_CHAN_WIDTH_80P80; 2309 else if (IEEE80211_IS_CHAN_VHT160(ni->ni_chan)) 2310 chanctx_conf->def.width = NL80211_CHAN_WIDTH_160; 2311 else if (IEEE80211_IS_CHAN_VHT80(ni->ni_chan)) 2312 chanctx_conf->def.width = NL80211_CHAN_WIDTH_80; 2313 } 2314 #endif 2315 chanctx_conf->rx_chains_dynamic = lkpi_get_max_rx_chains(ni); 2316 /* Responder ... */ 2317 #if 0 2318 chanctx_conf->min_def.chan = chanctx_conf->def.chan; 2319 chanctx_conf->min_def.width = NL80211_CHAN_WIDTH_20_NOHT; 2320 #ifdef LKPI_80211_HT 2321 if (IEEE80211_IS_CHAN_HT(ni->ni_chan) || IEEE80211_IS_CHAN_VHT(ni->ni_chan)) 2322 chanctx_conf->min_def.width = NL80211_CHAN_WIDTH_20; 2323 #endif 2324 chanctx_conf->min_def.center_freq1 = chanctx_conf->def.center_freq1; 2325 chanctx_conf->min_def.center_freq2 = chanctx_conf->def.center_freq2; 2326 #else 2327 chanctx_conf->min_def = chanctx_conf->def; 2328 #endif 2329 2330 /* Set bss info (bss_info_changed). */ 2331 bss_changed = 0; 2332 vif->bss_conf.bssid = ni->ni_bssid; 2333 bss_changed |= BSS_CHANGED_BSSID; 2334 vif->bss_conf.txpower = ni->ni_txpower; 2335 bss_changed |= BSS_CHANGED_TXPOWER; 2336 vif->cfg.idle = false; 2337 bss_changed |= BSS_CHANGED_IDLE; 2338 2339 /* vif->bss_conf.basic_rates ? Where exactly? */ 2340 2341 lvif->beacons = 0; 2342 /* Should almost assert it is this. */ 2343 vif->cfg.assoc = false; 2344 vif->cfg.aid = 0; 2345 2346 bss_changed |= lkpi_update_dtim_tsf(vif, ni, vap, __func__, __LINE__); 2347 2348 error = 0; 2349 if (vif->bss_conf.chanctx_conf == chanctx_conf) { 2350 changed = IEEE80211_CHANCTX_CHANGE_MIN_WIDTH; 2351 changed |= IEEE80211_CHANCTX_CHANGE_RADAR; 2352 changed |= IEEE80211_CHANCTX_CHANGE_RX_CHAINS; 2353 changed |= IEEE80211_CHANCTX_CHANGE_WIDTH; 2354 lkpi_80211_mo_change_chanctx(hw, chanctx_conf, changed); 2355 } else { 2356 /* The device is no longer idle. */ 2357 IMPROVE("Once we do multi-vif, only do for 1st chanctx"); 2358 lkpi_hw_conf_idle(hw, false); 2359 2360 error = lkpi_80211_mo_add_chanctx(hw, chanctx_conf); 2361 if (error == 0 || error == EOPNOTSUPP) { 2362 vif->bss_conf.chanreq.oper.chan = chanctx_conf->def.chan; 2363 vif->bss_conf.chanreq.oper.width = chanctx_conf->def.width; 2364 vif->bss_conf.chanreq.oper.center_freq1 = 2365 chanctx_conf->def.center_freq1; 2366 vif->bss_conf.chanreq.oper.center_freq2 = 2367 chanctx_conf->def.center_freq2; 2368 } else { 2369 ic_printf(vap->iv_ic, "%s:%d: mo_add_chanctx " 2370 "failed: %d\n", __func__, __LINE__, error); 2371 goto out; 2372 } 2373 2374 list_add_rcu(&lchanctx->entry, &lhw->lchanctx_list); 2375 rcu_assign_pointer(vif->bss_conf.chanctx_conf, chanctx_conf); 2376 2377 /* Assign vif chanctx. */ 2378 if (error == 0) 2379 error = lkpi_80211_mo_assign_vif_chanctx(hw, vif, 2380 &vif->bss_conf, chanctx_conf); 2381 if (error == EOPNOTSUPP) 2382 error = 0; 2383 if (error != 0) { 2384 ic_printf(vap->iv_ic, "%s:%d: mo_assign_vif_chanctx " 2385 "failed: %d\n", __func__, __LINE__, error); 2386 lkpi_80211_mo_remove_chanctx(hw, chanctx_conf); 2387 rcu_assign_pointer(vif->bss_conf.chanctx_conf, NULL); 2388 lchanctx = CHANCTX_CONF_TO_LCHANCTX(chanctx_conf); 2389 list_del(&lchanctx->entry); 2390 free(lchanctx, M_LKPI80211); 2391 goto out; 2392 } 2393 } 2394 IMPROVE("update radiotap chan fields too"); 2395 2396 /* RATES */ 2397 IMPROVE("bss info: not all needs to come now and rates are missing"); 2398 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, bss_changed); 2399 2400 /* 2401 * Given ni and lsta are 1:1 from alloc to free we can assert that 2402 * ni always has lsta data attach despite net80211 node swapping 2403 * under the hoods. 2404 */ 2405 KASSERT(ni->ni_drv_data != NULL, ("%s: ni %p ni_drv_data %p\n", 2406 __func__, ni, ni->ni_drv_data)); 2407 lsta = ni->ni_drv_data; 2408 2409 /* Insert the [l]sta into the list of known stations. */ 2410 list_add_tail(&lsta->lsta_list, &lvif->lsta_list); 2411 2412 /* Add (or adjust) sta and change state (from NOTEXIST) to NONE. */ 2413 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 2414 KASSERT(lsta->state == IEEE80211_STA_NOTEXIST, ("%s: lsta %p state not " 2415 "NOTEXIST: %#x\n", __func__, lsta, lsta->state)); 2416 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_NONE); 2417 if (error != 0) { 2418 IMPROVE("do we need to undo the chan ctx?"); 2419 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(NONE) " 2420 "failed: %d\n", __func__, __LINE__, error); 2421 goto out; 2422 } 2423 #if 0 2424 lsta->added_to_drv = true; /* mo manages. */ 2425 #endif 2426 2427 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 2428 2429 #if 0 2430 /* 2431 * Wakeup all queues now that sta is there so we have as much time to 2432 * possibly prepare the queue in the driver to be ready for the 1st 2433 * packet; lkpi_80211_txq_tx_one() still has a workaround as there 2434 * is no guarantee or way to check. 2435 * XXX-BZ and by now we know that this does not work on all drivers 2436 * for all queues. 2437 */ 2438 lkpi_wake_tx_queues(hw, LSTA_TO_STA(lsta), false, false); 2439 #endif 2440 2441 /* Start mgd_prepare_tx. */ 2442 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2443 prep_tx_info.duration = PREP_TX_INFO_DURATION; 2444 lkpi_80211_mo_mgd_prepare_tx(hw, vif, &prep_tx_info); 2445 lsta->in_mgd = true; 2446 2447 /* 2448 * What is going to happen next: 2449 * - <twiddle> .. we should end up in "auth_to_assoc" 2450 * - event_callback 2451 * - update sta_state (NONE to AUTH) 2452 * - mgd_complete_tx 2453 * (ideally we'd do that on a callback for something else ...) 2454 */ 2455 2456 wiphy_unlock(hw->wiphy); 2457 IEEE80211_LOCK(vap->iv_ic); 2458 2459 LKPI_80211_LVIF_LOCK(lvif); 2460 /* Re-check given (*iv_update_bss) could have happened while we were unlocked. */ 2461 if (lvif->lvif_bss_synched || lvif->lvif_bss != NULL || 2462 lsta->ni != vap->iv_bss) 2463 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 2464 "lvif_bss->ni %p synched %d, ni %p lsta %p\n", __func__, __LINE__, 2465 lvif, vap, vap->iv_bss, lvif->lvif_bss, 2466 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 2467 lvif->lvif_bss_synched, ni, lsta); 2468 2469 /* 2470 * Reference the "ni" for caching the lsta/ni in lvif->lvif_bss. 2471 * Given we cache lsta we use lsta->ni instead of ni here (even though 2472 * lsta->ni == ni) to be distinct from the rest of the code where we do 2473 * assume that ni == vap->iv_bss which it may or may not be. 2474 * So do NOT use iv_bss here anymore as that may have diverged from our 2475 * function local ni already while ic was unlocked and would lead to 2476 * inconsistencies. Go and see if we lost a race and do not update 2477 * lvif_bss_synched in that case. 2478 */ 2479 ieee80211_ref_node(lsta->ni); 2480 lvif->lvif_bss = lsta; 2481 if (lsta->ni == vap->iv_bss) { 2482 lvif->lvif_bss_synched = synched = true; 2483 } else { 2484 /* Set to un-synched no matter what. */ 2485 lvif->lvif_bss_synched = synched = false; 2486 /* 2487 * We do not error as someone has to take us down. 2488 * If we are followed by a 2nd, new net80211::join1() going to 2489 * AUTH lkpi_sta_a_to_a() will error, lkpi_sta_auth_to_{scan,init}() 2490 * will take the lvif->lvif_bss node down eventually. 2491 * What happens with the vap->iv_bss node will entirely be up 2492 * to net80211 as we never used the node beyond alloc()/free() 2493 * and we do not hold an extra reference for that anymore given 2494 * ni : lsta == 1:1. 2495 * Problem is if we do not error a MGMT/AUTH frame will be 2496 * sent from net80211::sta_newstate(); disable lsta queue below. 2497 */ 2498 } 2499 LKPI_80211_LVIF_UNLOCK(lvif); 2500 /* 2501 * Make sure in case the sta did not change and we re-added it, 2502 * that we can tx again but only if the vif/iv_bss are in sync. 2503 * Otherwise this should prevent the MGMT/AUTH frame from being 2504 * sent triggering a warning in iwlwifi. 2505 */ 2506 LKPI_80211_LSTA_TXQ_LOCK(lsta); 2507 lsta->txq_ready = synched; 2508 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 2509 goto out_relocked; 2510 2511 out: 2512 wiphy_unlock(hw->wiphy); 2513 IEEE80211_LOCK(vap->iv_ic); 2514 out_relocked: 2515 /* 2516 * Release the reference that kept the ni stable locally 2517 * during the work of this function. 2518 */ 2519 if (ni != NULL) 2520 ieee80211_free_node(ni); 2521 return (error); 2522 } 2523 2524 static int 2525 lkpi_sta_auth_to_scan(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2526 { 2527 struct lkpi_hw *lhw; 2528 struct ieee80211_hw *hw; 2529 struct lkpi_vif *lvif; 2530 struct ieee80211_vif *vif; 2531 struct ieee80211_node *ni; 2532 struct lkpi_sta *lsta; 2533 struct ieee80211_sta *sta; 2534 struct ieee80211_prep_tx_info prep_tx_info; 2535 enum ieee80211_bss_changed bss_changed; 2536 int error; 2537 2538 lhw = vap->iv_ic->ic_softc; 2539 hw = LHW_TO_HW(lhw); 2540 lvif = VAP_TO_LVIF(vap); 2541 vif = LVIF_TO_VIF(lvif); 2542 2543 LKPI_80211_LVIF_LOCK(lvif); 2544 #ifdef LINUXKPI_DEBUG_80211 2545 /* XXX-BZ KASSERT later; state going down so no action. */ 2546 if (lvif->lvif_bss == NULL) 2547 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 2548 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 2549 lvif, vap, vap->iv_bss, lvif->lvif_bss, 2550 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 2551 lvif->lvif_bss_synched); 2552 #endif 2553 2554 lsta = lvif->lvif_bss; 2555 LKPI_80211_LVIF_UNLOCK(lvif); 2556 KASSERT(lsta != NULL && lsta->ni != NULL, ("%s: lsta %p ni %p " 2557 "lvif %p vap %p\n", __func__, 2558 lsta, (lsta != NULL) ? lsta->ni : NULL, lvif, vap)); 2559 ni = lsta->ni; /* Reference held for lvif_bss. */ 2560 sta = LSTA_TO_STA(lsta); 2561 2562 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 2563 2564 IEEE80211_UNLOCK(vap->iv_ic); 2565 wiphy_lock(hw->wiphy); 2566 2567 /* flush, drop. */ 2568 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), true); 2569 2570 /* Wake tx queues to get packet(s) out. */ 2571 lkpi_wake_tx_queues(hw, sta, false, true); 2572 2573 /* flush, no drop */ 2574 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), false); 2575 2576 /* End mgd_complete_tx. */ 2577 if (lsta->in_mgd) { 2578 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2579 prep_tx_info.success = false; 2580 lkpi_80211_mo_mgd_complete_tx(hw, vif, &prep_tx_info); 2581 lsta->in_mgd = false; 2582 } 2583 2584 /* sync_rx_queues */ 2585 lkpi_80211_mo_sync_rx_queues(hw); 2586 2587 /* sta_pre_rcu_remove */ 2588 lkpi_80211_mo_sta_pre_rcu_remove(hw, vif, sta); 2589 2590 /* Take the station down. */ 2591 2592 /* Adjust sta and change state (from NONE) to NOTEXIST. */ 2593 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 2594 KASSERT(lsta->state == IEEE80211_STA_NONE, ("%s: lsta %p state not " 2595 "NONE: %#x, nstate %d arg %d\n", __func__, lsta, lsta->state, nstate, arg)); 2596 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_NOTEXIST); 2597 if (error != 0) { 2598 IMPROVE("do we need to undo the chan ctx?"); 2599 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(NOTEXIST) " 2600 "failed: %d\n", __func__, __LINE__, error); 2601 goto out; 2602 } 2603 #if 0 2604 lsta->added_to_drv = false; /* mo manages. */ 2605 #endif 2606 2607 bss_changed = 0; 2608 vif->bss_conf.dtim_period = 0; /* go back to 0. */ 2609 bss_changed |= BSS_CHANGED_BEACON_INFO; 2610 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, bss_changed); 2611 2612 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 2613 2614 LKPI_80211_LVIF_LOCK(lvif); 2615 /* Remove ni reference for this cache of lsta. */ 2616 lvif->lvif_bss = NULL; 2617 lvif->lvif_bss_synched = false; 2618 LKPI_80211_LVIF_UNLOCK(lvif); 2619 lkpi_lsta_remove(lsta, lvif); 2620 2621 /* conf_tx */ 2622 2623 lkpi_remove_chanctx(hw, vif); 2624 2625 out: 2626 wiphy_unlock(hw->wiphy); 2627 IEEE80211_LOCK(vap->iv_ic); 2628 if (error == 0) { 2629 /* 2630 * We do this outside the wiphy lock as net80211::node_free() may call 2631 * into crypto code to delete keys and we have a recursed on 2632 * non-recursive sx panic. Also only do this if we get here w/o error. 2633 * 2634 * The very last release the reference on the ni for the ni/lsta on 2635 * lvif->lvif_bss. Upon return from this both ni and lsta are invalid 2636 * and potentially freed. 2637 */ 2638 ieee80211_free_node(ni); 2639 } 2640 return (error); 2641 } 2642 2643 static int 2644 lkpi_sta_auth_to_init(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2645 { 2646 int error; 2647 2648 error = lkpi_sta_auth_to_scan(vap, nstate, arg); 2649 if (error == 0) 2650 error = lkpi_sta_scan_to_init(vap, nstate, arg); 2651 return (error); 2652 } 2653 2654 static int 2655 lkpi_sta_auth_to_assoc(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2656 { 2657 struct lkpi_hw *lhw; 2658 struct ieee80211_hw *hw; 2659 struct lkpi_vif *lvif; 2660 struct ieee80211_vif *vif; 2661 struct lkpi_sta *lsta; 2662 struct ieee80211_prep_tx_info prep_tx_info; 2663 int error; 2664 2665 lhw = vap->iv_ic->ic_softc; 2666 hw = LHW_TO_HW(lhw); 2667 lvif = VAP_TO_LVIF(vap); 2668 vif = LVIF_TO_VIF(lvif); 2669 2670 IEEE80211_UNLOCK(vap->iv_ic); 2671 wiphy_lock(hw->wiphy); 2672 2673 LKPI_80211_LVIF_LOCK(lvif); 2674 /* XXX-BZ KASSERT later? */ 2675 if (!lvif->lvif_bss_synched || lvif->lvif_bss == NULL) { 2676 #ifdef LINUXKPI_DEBUG_80211 2677 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 2678 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 2679 lvif, vap, vap->iv_bss, lvif->lvif_bss, 2680 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 2681 lvif->lvif_bss_synched); 2682 #endif 2683 error = ENOTRECOVERABLE; 2684 LKPI_80211_LVIF_UNLOCK(lvif); 2685 goto out; 2686 } 2687 lsta = lvif->lvif_bss; 2688 LKPI_80211_LVIF_UNLOCK(lvif); 2689 2690 KASSERT(lsta != NULL, ("%s: lsta %p\n", __func__, lsta)); 2691 2692 /* Finish auth. */ 2693 IMPROVE("event callback"); 2694 2695 /* Update sta_state (NONE to AUTH). */ 2696 KASSERT(lsta->state == IEEE80211_STA_NONE, ("%s: lsta %p state not " 2697 "NONE: %#x\n", __func__, lsta, lsta->state)); 2698 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_AUTH); 2699 if (error != 0) { 2700 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(AUTH) " 2701 "failed: %d\n", __func__, __LINE__, error); 2702 goto out; 2703 } 2704 2705 /* End mgd_complete_tx. */ 2706 if (lsta->in_mgd) { 2707 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2708 prep_tx_info.success = true; 2709 lkpi_80211_mo_mgd_complete_tx(hw, vif, &prep_tx_info); 2710 lsta->in_mgd = false; 2711 } 2712 2713 /* Now start assoc. */ 2714 2715 /* Start mgd_prepare_tx. */ 2716 if (!lsta->in_mgd) { 2717 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2718 prep_tx_info.duration = PREP_TX_INFO_DURATION; 2719 lkpi_80211_mo_mgd_prepare_tx(hw, vif, &prep_tx_info); 2720 lsta->in_mgd = true; 2721 } 2722 2723 /* Wake tx queue to get packet out. */ 2724 lkpi_wake_tx_queues(hw, LSTA_TO_STA(lsta), false, true); 2725 2726 /* 2727 * <twiddle> .. we end up in "assoc_to_run" 2728 * - update sta_state (AUTH to ASSOC) 2729 * - conf_tx [all] 2730 * - bss_info_changed (assoc, aid, ssid, ..) 2731 * - change_chanctx (if needed) 2732 * - event_callback 2733 * - mgd_complete_tx 2734 */ 2735 2736 out: 2737 wiphy_unlock(hw->wiphy); 2738 IEEE80211_LOCK(vap->iv_ic); 2739 return (error); 2740 } 2741 2742 /* auth_to_auth, assoc_to_assoc. */ 2743 static int 2744 lkpi_sta_a_to_a(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2745 { 2746 struct lkpi_hw *lhw; 2747 struct ieee80211_hw *hw; 2748 struct lkpi_vif *lvif; 2749 struct ieee80211_vif *vif; 2750 struct lkpi_sta *lsta; 2751 struct ieee80211_prep_tx_info prep_tx_info; 2752 int error; 2753 2754 lhw = vap->iv_ic->ic_softc; 2755 hw = LHW_TO_HW(lhw); 2756 lvif = VAP_TO_LVIF(vap); 2757 vif = LVIF_TO_VIF(lvif); 2758 2759 IEEE80211_UNLOCK(vap->iv_ic); 2760 wiphy_lock(hw->wiphy); 2761 2762 LKPI_80211_LVIF_LOCK(lvif); 2763 /* XXX-BZ KASSERT later? */ 2764 if (!lvif->lvif_bss_synched || lvif->lvif_bss == NULL) { 2765 #ifdef LINUXKPI_DEBUG_80211 2766 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 2767 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 2768 lvif, vap, vap->iv_bss, lvif->lvif_bss, 2769 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 2770 lvif->lvif_bss_synched); 2771 #endif 2772 LKPI_80211_LVIF_UNLOCK(lvif); 2773 error = ENOTRECOVERABLE; 2774 goto out; 2775 } 2776 lsta = lvif->lvif_bss; 2777 LKPI_80211_LVIF_UNLOCK(lvif); 2778 2779 KASSERT(lsta != NULL, ("%s: lsta %p! lvif %p vap %p\n", __func__, 2780 lsta, lvif, vap)); 2781 2782 IMPROVE("event callback?"); 2783 2784 /* End mgd_complete_tx. */ 2785 if (lsta->in_mgd) { 2786 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2787 prep_tx_info.success = false; 2788 lkpi_80211_mo_mgd_complete_tx(hw, vif, &prep_tx_info); 2789 lsta->in_mgd = false; 2790 } 2791 2792 /* Now start assoc. */ 2793 2794 /* Start mgd_prepare_tx. */ 2795 if (!lsta->in_mgd) { 2796 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2797 prep_tx_info.duration = PREP_TX_INFO_DURATION; 2798 lkpi_80211_mo_mgd_prepare_tx(hw, vif, &prep_tx_info); 2799 lsta->in_mgd = true; 2800 } 2801 2802 error = 0; 2803 out: 2804 wiphy_unlock(hw->wiphy); 2805 IEEE80211_LOCK(vap->iv_ic); 2806 2807 return (error); 2808 } 2809 2810 static int 2811 _lkpi_sta_assoc_to_down(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2812 { 2813 struct lkpi_hw *lhw; 2814 struct ieee80211_hw *hw; 2815 struct lkpi_vif *lvif; 2816 struct ieee80211_vif *vif; 2817 struct ieee80211_node *ni; 2818 struct lkpi_sta *lsta; 2819 struct ieee80211_sta *sta; 2820 struct ieee80211_prep_tx_info prep_tx_info; 2821 enum ieee80211_bss_changed bss_changed; 2822 int error; 2823 2824 lhw = vap->iv_ic->ic_softc; 2825 hw = LHW_TO_HW(lhw); 2826 lvif = VAP_TO_LVIF(vap); 2827 vif = LVIF_TO_VIF(lvif); 2828 2829 IEEE80211_UNLOCK(vap->iv_ic); 2830 wiphy_lock(hw->wiphy); 2831 2832 LKPI_80211_LVIF_LOCK(lvif); 2833 #ifdef LINUXKPI_DEBUG_80211 2834 /* XXX-BZ KASSERT later; state going down so no action. */ 2835 if (lvif->lvif_bss == NULL) 2836 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 2837 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 2838 lvif, vap, vap->iv_bss, lvif->lvif_bss, 2839 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 2840 lvif->lvif_bss_synched); 2841 #endif 2842 lsta = lvif->lvif_bss; 2843 LKPI_80211_LVIF_UNLOCK(lvif); 2844 KASSERT(lsta != NULL && lsta->ni != NULL, ("%s: lsta %p ni %p " 2845 "lvif %p vap %p\n", __func__, 2846 lsta, (lsta != NULL) ? lsta->ni : NULL, lvif, vap)); 2847 2848 ni = lsta->ni; /* Reference held for lvif_bss. */ 2849 sta = LSTA_TO_STA(lsta); 2850 2851 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 2852 2853 /* flush, drop. */ 2854 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), true); 2855 2856 IMPROVE("What are the proper conditions for DEAUTH_NEED_MGD_TX_PREP?"); 2857 if (ieee80211_hw_check(hw, DEAUTH_NEED_MGD_TX_PREP) && 2858 !lsta->in_mgd) { 2859 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2860 prep_tx_info.duration = PREP_TX_INFO_DURATION; 2861 prep_tx_info.was_assoc = true; 2862 lkpi_80211_mo_mgd_prepare_tx(hw, vif, &prep_tx_info); 2863 lsta->in_mgd = true; 2864 } 2865 2866 wiphy_unlock(hw->wiphy); 2867 IEEE80211_LOCK(vap->iv_ic); 2868 2869 /* Call iv_newstate first so we get potential DEAUTH packet out. */ 2870 error = lvif->iv_newstate(vap, nstate, arg); 2871 if (error != 0) { 2872 ic_printf(vap->iv_ic, "%s:%d: iv_newstate(%p, %d, %d) " 2873 "failed: %d\n", __func__, __LINE__, vap, nstate, arg, error); 2874 goto outni; 2875 } 2876 2877 IEEE80211_UNLOCK(vap->iv_ic); 2878 2879 /* Ensure the packets get out. */ 2880 lkpi_80211_flush_tx(lhw, lsta); 2881 2882 wiphy_lock(hw->wiphy); 2883 2884 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 2885 2886 /* Wake tx queues to get packet(s) out. */ 2887 lkpi_wake_tx_queues(hw, sta, false, true); 2888 2889 /* flush, no drop */ 2890 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), false); 2891 2892 /* End mgd_complete_tx. */ 2893 if (lsta->in_mgd) { 2894 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 2895 prep_tx_info.success = false; 2896 prep_tx_info.was_assoc = true; 2897 lkpi_80211_mo_mgd_complete_tx(hw, vif, &prep_tx_info); 2898 lsta->in_mgd = false; 2899 } 2900 2901 /* sync_rx_queues */ 2902 lkpi_80211_mo_sync_rx_queues(hw); 2903 2904 /* sta_pre_rcu_remove */ 2905 lkpi_80211_mo_sta_pre_rcu_remove(hw, vif, sta); 2906 2907 /* Take the station down. */ 2908 2909 /* Update sta and change state (from AUTH) to NONE. */ 2910 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 2911 KASSERT(lsta->state == IEEE80211_STA_AUTH, ("%s: lsta %p state not " 2912 "AUTH: %#x\n", __func__, lsta, lsta->state)); 2913 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_NONE); 2914 if (error != 0) { 2915 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(NONE) " 2916 "failed: %d\n", __func__, __LINE__, error); 2917 goto out; 2918 } 2919 2920 /* See comment in lkpi_sta_run_to_init(). */ 2921 bss_changed = 0; 2922 bss_changed |= lkpi_disassoc(sta, vif, lhw); 2923 2924 #ifdef LKPI_80211_HW_CRYPTO 2925 /* 2926 * In theory we remove keys here but there must not exist any for this 2927 * state change until we clean them up again into small steps and no 2928 * code duplication. 2929 */ 2930 #endif 2931 2932 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 2933 2934 /* Adjust sta and change state (from NONE) to NOTEXIST. */ 2935 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 2936 KASSERT(lsta->state == IEEE80211_STA_NONE, ("%s: lsta %p state not " 2937 "NONE: %#x, nstate %d arg %d\n", __func__, lsta, lsta->state, nstate, arg)); 2938 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_NOTEXIST); 2939 if (error != 0) { 2940 IMPROVE("do we need to undo the chan ctx?"); 2941 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(NOTEXIST) " 2942 "failed: %d\n", __func__, __LINE__, error); 2943 goto out; 2944 } 2945 2946 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); /* sta no longer save to use. */ 2947 2948 IMPROVE("Any bss_info changes to announce?"); 2949 vif->bss_conf.qos = 0; 2950 bss_changed |= BSS_CHANGED_QOS; 2951 vif->cfg.ssid_len = 0; 2952 memset(vif->cfg.ssid, '\0', sizeof(vif->cfg.ssid)); 2953 bss_changed |= BSS_CHANGED_BSSID; 2954 vif->bss_conf.dtim_period = 0; /* go back to 0. */ 2955 bss_changed |= BSS_CHANGED_BEACON_INFO; 2956 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, bss_changed); 2957 2958 LKPI_80211_LVIF_LOCK(lvif); 2959 /* Remove ni reference for this cache of lsta. */ 2960 lvif->lvif_bss = NULL; 2961 lvif->lvif_bss_synched = false; 2962 LKPI_80211_LVIF_UNLOCK(lvif); 2963 lkpi_lsta_remove(lsta, lvif); 2964 2965 /* conf_tx */ 2966 2967 lkpi_remove_chanctx(hw, vif); 2968 2969 error = EALREADY; 2970 out: 2971 wiphy_unlock(hw->wiphy); 2972 IEEE80211_LOCK(vap->iv_ic); 2973 if (error == EALREADY) { 2974 /* 2975 * We do this outside the wiphy lock as net80211::node_free() may call 2976 * into crypto code to delete keys and we have a recursed on 2977 * non-recursive sx panic. Also only do this if we get here w/o error. 2978 * 2979 * The very last release the reference on the ni for the ni/lsta on 2980 * lvif->lvif_bss. Upon return from this both ni and lsta are invalid 2981 * and potentially freed. 2982 */ 2983 ieee80211_free_node(ni); 2984 } 2985 outni: 2986 return (error); 2987 } 2988 2989 static int 2990 lkpi_sta_assoc_to_auth(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2991 { 2992 int error; 2993 2994 error = _lkpi_sta_assoc_to_down(vap, nstate, arg); 2995 if (error != 0 && error != EALREADY) 2996 return (error); 2997 2998 /* At this point iv_bss is long a new node! */ 2999 3000 error |= lkpi_sta_scan_to_auth(vap, nstate, 0); 3001 return (error); 3002 } 3003 3004 static int 3005 lkpi_sta_assoc_to_scan(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3006 { 3007 int error; 3008 3009 error = _lkpi_sta_assoc_to_down(vap, nstate, arg); 3010 return (error); 3011 } 3012 3013 static int 3014 lkpi_sta_assoc_to_init(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3015 { 3016 int error; 3017 3018 error = _lkpi_sta_assoc_to_down(vap, nstate, arg); 3019 return (error); 3020 } 3021 3022 static int 3023 lkpi_sta_assoc_to_run(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3024 { 3025 struct lkpi_hw *lhw; 3026 struct ieee80211_hw *hw; 3027 struct lkpi_vif *lvif; 3028 struct ieee80211_vif *vif; 3029 struct ieee80211_node *ni; 3030 struct lkpi_sta *lsta; 3031 struct ieee80211_sta *sta; 3032 struct ieee80211_prep_tx_info prep_tx_info; 3033 enum ieee80211_bss_changed bss_changed; 3034 int error; 3035 3036 lhw = vap->iv_ic->ic_softc; 3037 hw = LHW_TO_HW(lhw); 3038 lvif = VAP_TO_LVIF(vap); 3039 vif = LVIF_TO_VIF(lvif); 3040 3041 IEEE80211_UNLOCK(vap->iv_ic); 3042 wiphy_lock(hw->wiphy); 3043 3044 LKPI_80211_LVIF_LOCK(lvif); 3045 /* XXX-BZ KASSERT later? */ 3046 if (!lvif->lvif_bss_synched || lvif->lvif_bss == NULL) { 3047 #ifdef LINUXKPI_DEBUG_80211 3048 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 3049 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 3050 lvif, vap, vap->iv_bss, lvif->lvif_bss, 3051 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 3052 lvif->lvif_bss_synched); 3053 #endif 3054 LKPI_80211_LVIF_UNLOCK(lvif); 3055 error = ENOTRECOVERABLE; 3056 goto out; 3057 } 3058 lsta = lvif->lvif_bss; 3059 LKPI_80211_LVIF_UNLOCK(lvif); 3060 KASSERT(lsta != NULL && lsta->ni != NULL, ("%s: lsta %p ni %p " 3061 "lvif %p vap %p\n", __func__, 3062 lsta, (lsta != NULL) ? lsta->ni : NULL, lvif, vap)); 3063 3064 ni = lsta->ni; /* Reference held for lvif_bss. */ 3065 3066 IMPROVE("ponder some of this moved to ic_newassoc, scan_assoc_success, " 3067 "and to lesser extend ieee80211_notify_node_join"); 3068 3069 /* Finish assoc. */ 3070 /* Update sta_state (AUTH to ASSOC) and set aid. */ 3071 KASSERT(lsta->state == IEEE80211_STA_AUTH, ("%s: lsta %p state not " 3072 "AUTH: %#x\n", __func__, lsta, lsta->state)); 3073 sta = LSTA_TO_STA(lsta); 3074 sta->aid = IEEE80211_NODE_AID(ni); 3075 #ifdef LKPI_80211_WME 3076 if (vap->iv_flags & IEEE80211_F_WME) 3077 sta->wme = true; 3078 #endif 3079 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_ASSOC); 3080 if (error != 0) { 3081 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(ASSOC) " 3082 "failed: %d\n", __func__, __LINE__, error); 3083 goto out; 3084 } 3085 3086 IMPROVE("wme / conf_tx [all]"); 3087 3088 /* Update bss info (bss_info_changed) (assoc, aid, ..). */ 3089 bss_changed = 0; 3090 #ifdef LKPI_80211_WME 3091 bss_changed |= lkpi_wme_update(lhw, vap, true); 3092 #endif 3093 if (!vif->cfg.assoc || vif->cfg.aid != IEEE80211_NODE_AID(ni)) { 3094 lvif->beacons = 0; 3095 vif->cfg.assoc = true; 3096 vif->cfg.aid = IEEE80211_NODE_AID(ni); 3097 bss_changed |= BSS_CHANGED_ASSOC; 3098 } 3099 /* We set SSID but this is not BSSID! */ 3100 vif->cfg.ssid_len = ni->ni_esslen; 3101 memcpy(vif->cfg.ssid, ni->ni_essid, ni->ni_esslen); 3102 if ((vap->iv_flags & IEEE80211_F_SHPREAMBLE) != 3103 vif->bss_conf.use_short_preamble) { 3104 vif->bss_conf.use_short_preamble ^= 1; 3105 /* bss_changed |= BSS_CHANGED_??? */ 3106 } 3107 if ((vap->iv_flags & IEEE80211_F_SHSLOT) != 3108 vif->bss_conf.use_short_slot) { 3109 vif->bss_conf.use_short_slot ^= 1; 3110 /* bss_changed |= BSS_CHANGED_??? */ 3111 } 3112 if ((ni->ni_flags & IEEE80211_NODE_QOS) != 3113 vif->bss_conf.qos) { 3114 vif->bss_conf.qos ^= 1; 3115 bss_changed |= BSS_CHANGED_QOS; 3116 } 3117 3118 bss_changed |= lkpi_update_dtim_tsf(vif, ni, vap, __func__, __LINE__); 3119 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, bss_changed); 3120 3121 /* - change_chanctx (if needed) 3122 * - event_callback 3123 */ 3124 3125 /* End mgd_complete_tx. */ 3126 if (lsta->in_mgd) { 3127 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 3128 prep_tx_info.success = true; 3129 lkpi_80211_mo_mgd_complete_tx(hw, vif, &prep_tx_info); 3130 lsta->in_mgd = false; 3131 } 3132 3133 /* 3134 * And then: 3135 * - (more packets)? 3136 * - set_key 3137 * - set_default_unicast_key 3138 * - set_key (?) 3139 * - ipv6_addr_change (?) 3140 */ 3141 3142 if (!ieee80211_node_is_authorized(ni)) { 3143 IMPROVE("net80211 does not consider node authorized"); 3144 } 3145 3146 IMPROVE("Is this the right spot, has net80211 done all updates already?"); 3147 lkpi_sta_sync_from_ni(hw, vif, sta, ni, true); 3148 3149 /* Update thresholds. */ 3150 hw->wiphy->frag_threshold = vap->iv_fragthreshold; 3151 lkpi_80211_mo_set_frag_threshold(hw, vap->iv_fragthreshold); 3152 hw->wiphy->rts_threshold = vap->iv_rtsthreshold; 3153 lkpi_80211_mo_set_rts_threshold(hw, vap->iv_rtsthreshold); 3154 3155 /* Update sta_state (ASSOC to AUTHORIZED). */ 3156 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 3157 KASSERT(lsta->state == IEEE80211_STA_ASSOC, ("%s: lsta %p state not " 3158 "ASSOC: %#x\n", __func__, lsta, lsta->state)); 3159 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_AUTHORIZED); 3160 if (error != 0) { 3161 IMPROVE("undo some changes?"); 3162 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(AUTHORIZED) " 3163 "failed: %d\n", __func__, __LINE__, error); 3164 goto out; 3165 } 3166 3167 /* - drv_config (?) 3168 * - bss_info_changed 3169 * - set_rekey_data (?) 3170 * 3171 * And now we should be passing packets. 3172 */ 3173 IMPROVE("Need that bssid setting, and the keys"); 3174 3175 bss_changed = 0; 3176 bss_changed |= lkpi_update_dtim_tsf(vif, ni, vap, __func__, __LINE__); 3177 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, bss_changed); 3178 3179 /* Prepare_multicast && configure_filter. */ 3180 lkpi_update_mcast_filter(vap->iv_ic); 3181 3182 out: 3183 wiphy_unlock(hw->wiphy); 3184 IEEE80211_LOCK(vap->iv_ic); 3185 return (error); 3186 } 3187 3188 static int 3189 lkpi_sta_auth_to_run(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3190 { 3191 int error; 3192 3193 error = lkpi_sta_auth_to_assoc(vap, nstate, arg); 3194 if (error == 0) 3195 error = lkpi_sta_assoc_to_run(vap, nstate, arg); 3196 return (error); 3197 } 3198 3199 static int 3200 lkpi_sta_run_to_assoc(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3201 { 3202 struct lkpi_hw *lhw; 3203 struct ieee80211_hw *hw; 3204 struct lkpi_vif *lvif; 3205 struct ieee80211_vif *vif; 3206 struct ieee80211_node *ni; 3207 struct lkpi_sta *lsta; 3208 struct ieee80211_sta *sta; 3209 struct ieee80211_prep_tx_info prep_tx_info; 3210 #if 0 3211 enum ieee80211_bss_changed bss_changed; 3212 #endif 3213 int error; 3214 3215 lhw = vap->iv_ic->ic_softc; 3216 hw = LHW_TO_HW(lhw); 3217 lvif = VAP_TO_LVIF(vap); 3218 vif = LVIF_TO_VIF(lvif); 3219 3220 LKPI_80211_LVIF_LOCK(lvif); 3221 #ifdef LINUXKPI_DEBUG_80211 3222 /* XXX-BZ KASSERT later; state going down so no action. */ 3223 if (lvif->lvif_bss == NULL) 3224 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 3225 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 3226 lvif, vap, vap->iv_bss, lvif->lvif_bss, 3227 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 3228 lvif->lvif_bss_synched); 3229 #endif 3230 lsta = lvif->lvif_bss; 3231 LKPI_80211_LVIF_UNLOCK(lvif); 3232 KASSERT(lsta != NULL && lsta->ni != NULL, ("%s: lsta %p ni %p " 3233 "lvif %p vap %p\n", __func__, 3234 lsta, (lsta != NULL) ? lsta->ni : NULL, lvif, vap)); 3235 3236 ni = lsta->ni; /* Reference held for lvif_bss. */ 3237 sta = LSTA_TO_STA(lsta); 3238 3239 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3240 3241 IEEE80211_UNLOCK(vap->iv_ic); 3242 wiphy_lock(hw->wiphy); 3243 3244 /* flush, drop. */ 3245 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), true); 3246 3247 IMPROVE("What are the proper conditions for DEAUTH_NEED_MGD_TX_PREP?"); 3248 if (ieee80211_hw_check(hw, DEAUTH_NEED_MGD_TX_PREP) && 3249 !lsta->in_mgd) { 3250 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 3251 prep_tx_info.duration = PREP_TX_INFO_DURATION; 3252 prep_tx_info.was_assoc = true; 3253 lkpi_80211_mo_mgd_prepare_tx(hw, vif, &prep_tx_info); 3254 lsta->in_mgd = true; 3255 } 3256 3257 wiphy_unlock(hw->wiphy); 3258 IEEE80211_LOCK(vap->iv_ic); 3259 3260 /* Call iv_newstate first so we get potential DISASSOC packet out. */ 3261 error = lvif->iv_newstate(vap, nstate, arg); 3262 if (error != 0) { 3263 ic_printf(vap->iv_ic, "%s:%d: iv_newstate(%p, %d, %d) " 3264 "failed: %d\n", __func__, __LINE__, vap, nstate, arg, error); 3265 goto outni; 3266 } 3267 3268 IEEE80211_UNLOCK(vap->iv_ic); 3269 3270 /* Ensure the packets get out. */ 3271 lkpi_80211_flush_tx(lhw, lsta); 3272 3273 wiphy_lock(hw->wiphy); 3274 3275 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3276 3277 /* Wake tx queues to get packet(s) out. */ 3278 lkpi_wake_tx_queues(hw, sta, false, true); 3279 3280 /* flush, no drop */ 3281 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), false); 3282 3283 /* End mgd_complete_tx. */ 3284 if (lsta->in_mgd) { 3285 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 3286 prep_tx_info.success = false; 3287 prep_tx_info.was_assoc = true; 3288 lkpi_80211_mo_mgd_complete_tx(hw, vif, &prep_tx_info); 3289 lsta->in_mgd = false; 3290 } 3291 3292 #if 0 3293 /* sync_rx_queues */ 3294 lkpi_80211_mo_sync_rx_queues(hw); 3295 3296 /* sta_pre_rcu_remove */ 3297 lkpi_80211_mo_sta_pre_rcu_remove(hw, vif, sta); 3298 #endif 3299 3300 /* Take the station down. */ 3301 3302 /* Adjust sta and change state (from AUTHORIZED) to ASSOC. */ 3303 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 3304 KASSERT(lsta->state == IEEE80211_STA_AUTHORIZED, ("%s: lsta %p state not " 3305 "AUTHORIZED: %#x\n", __func__, lsta, lsta->state)); 3306 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_ASSOC); 3307 if (error != 0) { 3308 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(ASSOC) " 3309 "failed: %d\n", __func__, __LINE__, error); 3310 goto out; 3311 } 3312 3313 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3314 3315 #ifdef LKPI_80211_HW_CRYPTO 3316 if (lkpi_hwcrypto) { 3317 error = lkpi_sta_del_keys(hw, vif, lsta); 3318 if (error != 0) { 3319 ic_printf(vap->iv_ic, "%s:%d: lkpi_sta_del_keys " 3320 "failed: %d\n", __func__, __LINE__, error); 3321 /* 3322 * Either drv/fw will crash or cleanup itself, 3323 * otherwise net80211 will delete the keys (at a 3324 * less appropriate time). 3325 */ 3326 /* goto out; */ 3327 } 3328 } 3329 #endif 3330 3331 /* Update sta_state (ASSOC to AUTH). */ 3332 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 3333 KASSERT(lsta->state == IEEE80211_STA_ASSOC, ("%s: lsta %p state not " 3334 "ASSOC: %#x\n", __func__, lsta, lsta->state)); 3335 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_AUTH); 3336 if (error != 0) { 3337 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(AUTH) " 3338 "failed: %d\n", __func__, __LINE__, error); 3339 goto out; 3340 } 3341 3342 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3343 3344 #if 0 3345 /* Update bss info (bss_info_changed) (assoc, aid, ..). */ 3346 lkpi_disassoc(sta, vif, lhw); 3347 #endif 3348 3349 error = EALREADY; 3350 out: 3351 wiphy_unlock(hw->wiphy); 3352 IEEE80211_LOCK(vap->iv_ic); 3353 outni: 3354 return (error); 3355 } 3356 3357 static int 3358 lkpi_sta_run_to_init(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3359 { 3360 struct lkpi_hw *lhw; 3361 struct ieee80211_hw *hw; 3362 struct lkpi_vif *lvif; 3363 struct ieee80211_vif *vif; 3364 struct ieee80211_node *ni; 3365 struct lkpi_sta *lsta; 3366 struct ieee80211_sta *sta; 3367 struct ieee80211_prep_tx_info prep_tx_info; 3368 enum ieee80211_bss_changed bss_changed; 3369 int error; 3370 3371 lhw = vap->iv_ic->ic_softc; 3372 hw = LHW_TO_HW(lhw); 3373 lvif = VAP_TO_LVIF(vap); 3374 vif = LVIF_TO_VIF(lvif); 3375 3376 IEEE80211_UNLOCK(vap->iv_ic); 3377 wiphy_lock(hw->wiphy); 3378 3379 LKPI_80211_LVIF_LOCK(lvif); 3380 #ifdef LINUXKPI_DEBUG_80211 3381 /* XXX-BZ KASSERT later; state going down so no action. */ 3382 if (lvif->lvif_bss == NULL) 3383 ic_printf(vap->iv_ic, "%s:%d: lvif %p vap %p iv_bss %p lvif_bss %p " 3384 "lvif_bss->ni %p synched %d\n", __func__, __LINE__, 3385 lvif, vap, vap->iv_bss, lvif->lvif_bss, 3386 (lvif->lvif_bss != NULL) ? lvif->lvif_bss->ni : NULL, 3387 lvif->lvif_bss_synched); 3388 #endif 3389 lsta = lvif->lvif_bss; 3390 LKPI_80211_LVIF_UNLOCK(lvif); 3391 KASSERT(lsta != NULL && lsta->ni != NULL, ("%s: lsta %p ni %p " 3392 "lvif %p vap %p\n", __func__, 3393 lsta, (lsta != NULL) ? lsta->ni : NULL, lvif, vap)); 3394 3395 ni = lsta->ni; /* Reference held for lvif_bss. */ 3396 sta = LSTA_TO_STA(lsta); 3397 3398 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3399 3400 /* flush, drop. */ 3401 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), true); 3402 3403 IMPROVE("What are the proper conditions for DEAUTH_NEED_MGD_TX_PREP?"); 3404 if (ieee80211_hw_check(hw, DEAUTH_NEED_MGD_TX_PREP) && 3405 !lsta->in_mgd) { 3406 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 3407 prep_tx_info.duration = PREP_TX_INFO_DURATION; 3408 prep_tx_info.was_assoc = true; 3409 lkpi_80211_mo_mgd_prepare_tx(hw, vif, &prep_tx_info); 3410 lsta->in_mgd = true; 3411 } 3412 3413 wiphy_unlock(hw->wiphy); 3414 IEEE80211_LOCK(vap->iv_ic); 3415 3416 /* Call iv_newstate first so we get potential DISASSOC packet out. */ 3417 error = lvif->iv_newstate(vap, nstate, arg); 3418 if (error != 0) { 3419 ic_printf(vap->iv_ic, "%s:%d: iv_newstate(%p, %d, %d) " 3420 "failed: %d\n", __func__, __LINE__, vap, nstate, arg, error); 3421 goto outni; 3422 } 3423 3424 IEEE80211_UNLOCK(vap->iv_ic); 3425 3426 /* Ensure the packets get out. */ 3427 lkpi_80211_flush_tx(lhw, lsta); 3428 3429 wiphy_lock(hw->wiphy); 3430 3431 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3432 3433 /* Wake tx queues to get packet(s) out. */ 3434 lkpi_wake_tx_queues(hw, sta, false, true); 3435 3436 /* flush, no drop */ 3437 lkpi_80211_mo_flush(hw, vif, nitems(sta->txq), false); 3438 3439 /* End mgd_complete_tx. */ 3440 if (lsta->in_mgd) { 3441 memset(&prep_tx_info, 0, sizeof(prep_tx_info)); 3442 prep_tx_info.success = false; 3443 prep_tx_info.was_assoc = true; 3444 lkpi_80211_mo_mgd_complete_tx(hw, vif, &prep_tx_info); 3445 lsta->in_mgd = false; 3446 } 3447 3448 /* sync_rx_queues */ 3449 lkpi_80211_mo_sync_rx_queues(hw); 3450 3451 /* sta_pre_rcu_remove */ 3452 lkpi_80211_mo_sta_pre_rcu_remove(hw, vif, sta); 3453 3454 /* Take the station down. */ 3455 3456 /* Adjust sta and change state (from AUTHORIZED) to ASSOC. */ 3457 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 3458 KASSERT(lsta->state == IEEE80211_STA_AUTHORIZED, ("%s: lsta %p state not " 3459 "AUTHORIZED: %#x\n", __func__, lsta, lsta->state)); 3460 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_ASSOC); 3461 if (error != 0) { 3462 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(ASSOC) " 3463 "failed: %d\n", __func__, __LINE__, error); 3464 goto out; 3465 } 3466 3467 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3468 3469 #ifdef LKPI_80211_HW_CRYPTO 3470 if (lkpi_hwcrypto) { 3471 /* 3472 * In theory we only need to do this if we changed assoc. 3473 * If we were not assoc, there should be no keys and we 3474 * should not be here. 3475 */ 3476 #ifdef notyet 3477 KASSERT((bss_changed & BSS_CHANGED_ASSOC) != 0, ("%s: " 3478 "trying to remove keys but were not assoc: %#010jx, lvif %p\n", 3479 __func__, (uintmax_t)bss_changed, lvif)); 3480 #endif 3481 error = lkpi_sta_del_keys(hw, vif, lsta); 3482 if (error != 0) { 3483 ic_printf(vap->iv_ic, "%s:%d: lkpi_sta_del_keys " 3484 "failed: %d\n", __func__, __LINE__, error); 3485 /* 3486 * Either drv/fw will crash or cleanup itself, 3487 * otherwise net80211 will delete the keys (at a 3488 * less appropriate time). 3489 */ 3490 /* goto out; */ 3491 } 3492 } 3493 #endif 3494 3495 /* Update sta_state (ASSOC to AUTH). */ 3496 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 3497 KASSERT(lsta->state == IEEE80211_STA_ASSOC, ("%s: lsta %p state not " 3498 "ASSOC: %#x\n", __func__, lsta, lsta->state)); 3499 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_AUTH); 3500 if (error != 0) { 3501 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(AUTH) " 3502 "failed: %d\n", __func__, __LINE__, error); 3503 goto out; 3504 } 3505 3506 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3507 3508 /* Update sta and change state (from AUTH) to NONE. */ 3509 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 3510 KASSERT(lsta->state == IEEE80211_STA_AUTH, ("%s: lsta %p state not " 3511 "AUTH: %#x\n", __func__, lsta, lsta->state)); 3512 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_NONE); 3513 if (error != 0) { 3514 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(NONE) " 3515 "failed: %d\n", __func__, __LINE__, error); 3516 goto out; 3517 } 3518 3519 bss_changed = 0; 3520 /* 3521 * Start updating bss info (bss_info_changed) (assoc, aid, ..). 3522 * 3523 * One would expect this to happen when going off AUTHORIZED. 3524 * See comment there; removes the sta from fw if not careful 3525 * (bss_info_changed() change is executed right away). 3526 * 3527 * We need to do this now, before sta changes to IEEE80211_STA_NOTEXIST 3528 * as otherwise drivers (iwlwifi at least) will silently not remove 3529 * the sta from the firmware and when we will add a new one trigger 3530 * a fw assert. 3531 * 3532 * The order which works best so far avoiding early removal or silent 3533 * non-removal seems to be (for iwlwifi::mld-mac80211.c cases; 3534 * the iwlwifi:mac80211.c case still to be tested): 3535 * 1) lkpi_disassoc(): set vif->cfg.assoc = false (aid=0 side effect here) 3536 * 2) call the last sta_state update -> IEEE80211_STA_NOTEXIST 3537 * (removes the sta given assoc is false) 3538 * 3) add the remaining BSS_CHANGED changes and call bss_info_changed() 3539 * 4) call unassign_vif_chanctx 3540 * 5) call lkpi_hw_conf_idle 3541 * 6) call remove_chanctx 3542 * 3543 * Note: vif->driver_flags & IEEE80211_VIF_REMOVE_AP_AFTER_DISASSOC 3544 * might change this. 3545 */ 3546 bss_changed |= lkpi_disassoc(sta, vif, lhw); 3547 3548 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); 3549 3550 /* Adjust sta and change state (from NONE) to NOTEXIST. */ 3551 KASSERT(lsta != NULL, ("%s: ni %p lsta is NULL\n", __func__, ni)); 3552 KASSERT(lsta->state == IEEE80211_STA_NONE, ("%s: lsta %p state not " 3553 "NONE: %#x, nstate %d arg %d\n", __func__, lsta, lsta->state, nstate, arg)); 3554 error = lkpi_80211_mo_sta_state(hw, vif, lsta, IEEE80211_STA_NOTEXIST); 3555 if (error != 0) { 3556 IMPROVE("do we need to undo the chan ctx?"); 3557 ic_printf(vap->iv_ic, "%s:%d: mo_sta_state(NOTEXIST) " 3558 "failed: %d\n", __func__, __LINE__, error); 3559 goto out; 3560 } 3561 3562 lkpi_lsta_remove(lsta, lvif); 3563 3564 lkpi_lsta_dump(lsta, ni, __func__, __LINE__); /* sta no longer save to use. */ 3565 3566 IMPROVE("Any bss_info changes to announce?"); 3567 vif->bss_conf.qos = 0; 3568 bss_changed |= BSS_CHANGED_QOS; 3569 vif->cfg.ssid_len = 0; 3570 memset(vif->cfg.ssid, '\0', sizeof(vif->cfg.ssid)); 3571 bss_changed |= BSS_CHANGED_BSSID; 3572 vif->bss_conf.use_short_preamble = false; 3573 vif->bss_conf.qos = false; 3574 /* XXX BSS_CHANGED_???? */ 3575 vif->bss_conf.dtim_period = 0; /* go back to 0. */ 3576 bss_changed |= BSS_CHANGED_BEACON_INFO; 3577 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, bss_changed); 3578 3579 LKPI_80211_LVIF_LOCK(lvif); 3580 /* Remove ni reference for this cache of lsta. */ 3581 lvif->lvif_bss = NULL; 3582 lvif->lvif_bss_synched = false; 3583 LKPI_80211_LVIF_UNLOCK(lvif); 3584 3585 /* conf_tx */ 3586 3587 lkpi_remove_chanctx(hw, vif); 3588 3589 error = EALREADY; 3590 out: 3591 wiphy_unlock(hw->wiphy); 3592 IEEE80211_LOCK(vap->iv_ic); 3593 if (error == EALREADY) { 3594 /* 3595 * We do this outside the wiphy lock as net80211::node_free() may call 3596 * into crypto code to delete keys and we have a recursed on 3597 * non-recursive sx panic. Also only do this if we get here w/o error. 3598 * 3599 * The very last release the reference on the ni for the ni/lsta on 3600 * lvif->lvif_bss. Upon return from this both ni and lsta are invalid 3601 * and potentially freed. 3602 */ 3603 ieee80211_free_node(ni); 3604 } 3605 outni: 3606 return (error); 3607 } 3608 3609 static int 3610 lkpi_sta_run_to_scan(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3611 { 3612 3613 return (lkpi_sta_run_to_init(vap, nstate, arg)); 3614 } 3615 3616 static int 3617 lkpi_sta_run_to_auth(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3618 { 3619 int error; 3620 3621 error = lkpi_sta_run_to_init(vap, nstate, arg); 3622 if (error != 0 && error != EALREADY) 3623 return (error); 3624 3625 /* At this point iv_bss is long a new node! */ 3626 3627 error |= lkpi_sta_scan_to_auth(vap, nstate, 0); 3628 return (error); 3629 } 3630 3631 /* -------------------------------------------------------------------------- */ 3632 3633 /* 3634 * The matches the documented state changes in net80211::sta_newstate(). 3635 * XXX (1) without CSA and SLEEP yet, * XXX (2) not all unhandled cases 3636 * there are "invalid" (so there is a room for failure here). 3637 */ 3638 struct fsm_state { 3639 /* INIT, SCAN, AUTH, ASSOC, CAC, RUN, CSA, SLEEP */ 3640 enum ieee80211_state ostate; 3641 enum ieee80211_state nstate; 3642 int (*handler)(struct ieee80211vap *, enum ieee80211_state, int); 3643 } sta_state_fsm[] = { 3644 { IEEE80211_S_INIT, IEEE80211_S_INIT, lkpi_sta_state_do_nada }, 3645 { IEEE80211_S_SCAN, IEEE80211_S_INIT, lkpi_sta_state_do_nada }, /* scan_to_init */ 3646 { IEEE80211_S_AUTH, IEEE80211_S_INIT, lkpi_sta_auth_to_init }, /* not explicitly in sta_newstate() */ 3647 { IEEE80211_S_ASSOC, IEEE80211_S_INIT, lkpi_sta_assoc_to_init }, /* Send DEAUTH. */ 3648 { IEEE80211_S_RUN, IEEE80211_S_INIT, lkpi_sta_run_to_init }, /* Send DISASSOC. */ 3649 3650 { IEEE80211_S_INIT, IEEE80211_S_SCAN, lkpi_sta_state_do_nada }, 3651 { IEEE80211_S_SCAN, IEEE80211_S_SCAN, lkpi_sta_state_do_nada }, 3652 { IEEE80211_S_AUTH, IEEE80211_S_SCAN, lkpi_sta_auth_to_scan }, 3653 { IEEE80211_S_ASSOC, IEEE80211_S_SCAN, lkpi_sta_assoc_to_scan }, 3654 { IEEE80211_S_RUN, IEEE80211_S_SCAN, lkpi_sta_run_to_scan }, /* Beacon miss. */ 3655 3656 { IEEE80211_S_INIT, IEEE80211_S_AUTH, lkpi_sta_scan_to_auth }, /* Send AUTH. */ 3657 { IEEE80211_S_SCAN, IEEE80211_S_AUTH, lkpi_sta_scan_to_auth }, /* Send AUTH. */ 3658 { IEEE80211_S_AUTH, IEEE80211_S_AUTH, lkpi_sta_a_to_a }, /* Send ?AUTH. */ 3659 { IEEE80211_S_ASSOC, IEEE80211_S_AUTH, lkpi_sta_assoc_to_auth }, /* Send ?AUTH. */ 3660 { IEEE80211_S_RUN, IEEE80211_S_AUTH, lkpi_sta_run_to_auth }, /* Send ?AUTH. */ 3661 3662 { IEEE80211_S_AUTH, IEEE80211_S_ASSOC, lkpi_sta_auth_to_assoc }, /* Send ASSOCREQ. */ 3663 { IEEE80211_S_ASSOC, IEEE80211_S_ASSOC, lkpi_sta_a_to_a }, /* Send ASSOCREQ. */ 3664 { IEEE80211_S_RUN, IEEE80211_S_ASSOC, lkpi_sta_run_to_assoc }, /* Send ASSOCREQ/REASSOCREQ. */ 3665 3666 { IEEE80211_S_AUTH, IEEE80211_S_RUN, lkpi_sta_auth_to_run }, 3667 { IEEE80211_S_ASSOC, IEEE80211_S_RUN, lkpi_sta_assoc_to_run }, 3668 { IEEE80211_S_RUN, IEEE80211_S_RUN, lkpi_sta_state_do_nada }, 3669 3670 /* Dummy at the end without handler. */ 3671 { IEEE80211_S_INIT, IEEE80211_S_INIT, NULL }, 3672 }; 3673 3674 static int 3675 lkpi_iv_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 3676 { 3677 struct ieee80211com *ic; 3678 struct lkpi_hw *lhw; 3679 struct lkpi_vif *lvif; 3680 struct ieee80211_vif *vif; 3681 struct fsm_state *s; 3682 enum ieee80211_state ostate; 3683 int error; 3684 3685 ic = vap->iv_ic; 3686 IEEE80211_LOCK_ASSERT(ic); 3687 ostate = vap->iv_state; 3688 3689 #ifdef LINUXKPI_DEBUG_80211 3690 if (linuxkpi_debug_80211 & D80211_TRACE) 3691 ic_printf(vap->iv_ic, "%s:%d: vap %p nstate %#x arg %#x\n", 3692 __func__, __LINE__, vap, nstate, arg); 3693 #endif 3694 3695 if (vap->iv_opmode == IEEE80211_M_STA) { 3696 3697 lhw = ic->ic_softc; 3698 lvif = VAP_TO_LVIF(vap); 3699 vif = LVIF_TO_VIF(lvif); 3700 3701 /* No need to replicate this in most state handlers. */ 3702 if (nstate > IEEE80211_S_SCAN) 3703 lkpi_stop_hw_scan(lhw, vif); 3704 3705 s = sta_state_fsm; 3706 3707 } else { 3708 ic_printf(vap->iv_ic, "%s: only station mode currently supported: " 3709 "cap %p iv_opmode %d\n", __func__, vap, vap->iv_opmode); 3710 return (ENOSYS); 3711 } 3712 3713 error = 0; 3714 for (; s->handler != NULL; s++) { 3715 if (ostate == s->ostate && nstate == s->nstate) { 3716 #ifdef LINUXKPI_DEBUG_80211 3717 if (linuxkpi_debug_80211 & D80211_TRACE) 3718 ic_printf(vap->iv_ic, "%s: new state %d (%s) ->" 3719 " %d (%s): arg %d.\n", __func__, 3720 ostate, ieee80211_state_name[ostate], 3721 nstate, ieee80211_state_name[nstate], arg); 3722 #endif 3723 error = s->handler(vap, nstate, arg); 3724 break; 3725 } 3726 } 3727 IEEE80211_LOCK_ASSERT(vap->iv_ic); 3728 3729 if (s->handler == NULL) { 3730 IMPROVE("turn this into a KASSERT\n"); 3731 ic_printf(vap->iv_ic, "%s: unsupported state transition " 3732 "%d (%s) -> %d (%s)\n", __func__, 3733 ostate, ieee80211_state_name[ostate], 3734 nstate, ieee80211_state_name[nstate]); 3735 return (ENOSYS); 3736 } 3737 3738 if (error == EALREADY) { 3739 #ifdef LINUXKPI_DEBUG_80211 3740 if (linuxkpi_debug_80211 & D80211_TRACE) 3741 ic_printf(vap->iv_ic, "%s: state transition %d (%s) -> " 3742 "%d (%s): iv_newstate already handled: %d.\n", 3743 __func__, ostate, ieee80211_state_name[ostate], 3744 nstate, ieee80211_state_name[nstate], error); 3745 #endif 3746 return (0); 3747 } 3748 3749 if (error != 0) { 3750 ic_printf(vap->iv_ic, "%s: error %d during state transition " 3751 "%d (%s) -> %d (%s)\n", __func__, error, 3752 ostate, ieee80211_state_name[ostate], 3753 nstate, ieee80211_state_name[nstate]); 3754 return (error); 3755 } 3756 3757 #ifdef LINUXKPI_DEBUG_80211 3758 if (linuxkpi_debug_80211 & D80211_TRACE) 3759 ic_printf(vap->iv_ic, "%s:%d: vap %p nstate %#x arg %#x " 3760 "calling net80211 parent\n", 3761 __func__, __LINE__, vap, nstate, arg); 3762 #endif 3763 3764 return (lvif->iv_newstate(vap, nstate, arg)); 3765 } 3766 3767 /* -------------------------------------------------------------------------- */ 3768 3769 /* 3770 * We overload (*iv_update_bss) as otherwise we have cases in, e.g., 3771 * net80211::ieee80211_sta_join1() where vap->iv_bss gets replaced by a 3772 * new node without us knowing and thus our ni/lsta are out of sync. 3773 */ 3774 static struct ieee80211_node * 3775 lkpi_iv_update_bss(struct ieee80211vap *vap, struct ieee80211_node *ni) 3776 { 3777 struct lkpi_vif *lvif; 3778 struct ieee80211_node *rni; 3779 3780 IEEE80211_LOCK_ASSERT(vap->iv_ic); 3781 3782 lvif = VAP_TO_LVIF(vap); 3783 3784 LKPI_80211_LVIF_LOCK(lvif); 3785 lvif->lvif_bss_synched = false; 3786 LKPI_80211_LVIF_UNLOCK(lvif); 3787 3788 rni = lvif->iv_update_bss(vap, ni); 3789 return (rni); 3790 } 3791 3792 #ifdef LKPI_80211_WME 3793 static int 3794 lkpi_wme_update(struct lkpi_hw *lhw, struct ieee80211vap *vap, bool planned) 3795 { 3796 struct ieee80211com *ic; 3797 struct ieee80211_hw *hw; 3798 struct lkpi_vif *lvif; 3799 struct ieee80211_vif *vif; 3800 struct chanAccParams chp; 3801 struct wmeParams wmeparr[WME_NUM_AC]; 3802 struct ieee80211_tx_queue_params txqp; 3803 enum ieee80211_bss_changed changed; 3804 int error; 3805 uint16_t ac; 3806 3807 hw = LHW_TO_HW(lhw); 3808 lockdep_assert_wiphy(hw->wiphy); 3809 3810 IMPROVE(); 3811 KASSERT(WME_NUM_AC == IEEE80211_NUM_ACS, ("%s: WME_NUM_AC %d != " 3812 "IEEE80211_NUM_ACS %d\n", __func__, WME_NUM_AC, IEEE80211_NUM_ACS)); 3813 3814 if (vap == NULL) 3815 return (0); 3816 3817 if ((vap->iv_flags & IEEE80211_F_WME) == 0) 3818 return (0); 3819 3820 if (lhw->ops->conf_tx == NULL) 3821 return (0); 3822 3823 if (!planned && (vap->iv_state != IEEE80211_S_RUN)) { 3824 lhw->update_wme = true; 3825 return (0); 3826 } 3827 lhw->update_wme = false; 3828 3829 ic = lhw->ic; 3830 ieee80211_wme_ic_getparams(ic, &chp); 3831 IEEE80211_LOCK(ic); 3832 for (ac = 0; ac < WME_NUM_AC; ac++) 3833 wmeparr[ac] = chp.cap_wmeParams[ac]; 3834 IEEE80211_UNLOCK(ic); 3835 3836 lvif = VAP_TO_LVIF(vap); 3837 vif = LVIF_TO_VIF(lvif); 3838 3839 /* Configure tx queues (conf_tx) & send BSS_CHANGED_QOS. */ 3840 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 3841 struct wmeParams *wmep; 3842 3843 wmep = &wmeparr[ac]; 3844 bzero(&txqp, sizeof(txqp)); 3845 txqp.cw_min = wmep->wmep_logcwmin; 3846 txqp.cw_max = wmep->wmep_logcwmax; 3847 txqp.txop = wmep->wmep_txopLimit; 3848 txqp.aifs = wmep->wmep_aifsn; 3849 error = lkpi_80211_mo_conf_tx(hw, vif, /* link_id */0, ac, &txqp); 3850 if (error != 0) 3851 ic_printf(ic, "%s: conf_tx ac %u failed %d\n", 3852 __func__, ac, error); 3853 } 3854 changed = BSS_CHANGED_QOS; 3855 if (!planned) 3856 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, changed); 3857 3858 return (changed); 3859 } 3860 #endif 3861 3862 static int 3863 lkpi_ic_wme_update(struct ieee80211com *ic) 3864 { 3865 #ifdef LKPI_80211_WME 3866 struct ieee80211vap *vap; 3867 struct lkpi_hw *lhw; 3868 struct ieee80211_hw *hw; 3869 3870 IMPROVE("Use the per-VAP callback in net80211."); 3871 vap = TAILQ_FIRST(&ic->ic_vaps); 3872 if (vap == NULL) 3873 return (0); 3874 3875 lhw = ic->ic_softc; 3876 hw = LHW_TO_HW(lhw); 3877 3878 wiphy_lock(hw->wiphy); 3879 lkpi_wme_update(lhw, vap, false); 3880 wiphy_unlock(hw->wiphy); 3881 #endif 3882 return (0); /* unused */ 3883 } 3884 3885 static void 3886 lkpi_iv_sta_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0, 3887 int subtype, const struct ieee80211_rx_stats *rxs, int rssi, int nf) 3888 { 3889 struct lkpi_hw *lhw; 3890 struct ieee80211_hw *hw; 3891 struct lkpi_vif *lvif; 3892 struct ieee80211_vif *vif; 3893 enum ieee80211_bss_changed bss_changed; 3894 3895 lvif = VAP_TO_LVIF(ni->ni_vap); 3896 vif = LVIF_TO_VIF(lvif); 3897 3898 lvif->iv_recv_mgmt(ni, m0, subtype, rxs, rssi, nf); 3899 3900 switch (subtype) { 3901 case IEEE80211_FC0_SUBTYPE_PROBE_RESP: 3902 break; 3903 case IEEE80211_FC0_SUBTYPE_BEACON: 3904 /* 3905 * Only count beacons when assoc. SCAN has its own logging. 3906 * This is for connection/beacon loss/session protection almost 3907 * over debugging when trying to get into a stable RUN state. 3908 */ 3909 if (vif->cfg.assoc) 3910 lvif->beacons++; 3911 break; 3912 default: 3913 return; 3914 } 3915 3916 lhw = ni->ni_ic->ic_softc; 3917 hw = LHW_TO_HW(lhw); 3918 3919 /* 3920 * If this direct call to mo_bss_info_changed will not work due to 3921 * locking, see if queue_work() is fast enough. 3922 */ 3923 bss_changed = lkpi_update_dtim_tsf(vif, ni, ni->ni_vap, __func__, __LINE__); 3924 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, bss_changed); 3925 } 3926 3927 /* 3928 * Change link-layer address on the vif (if the vap is not started/"UP"). 3929 * This can happen if a user changes 'ether' using ifconfig. 3930 * The code is based on net80211/ieee80211_freebsd.c::wlan_iflladdr() but 3931 * we do use a per-[l]vif event handler to be sure we exist as we 3932 * cannot assume that from every vap derives a vif and we have a hard 3933 * time checking based on net80211 information. 3934 * Should this ever become a real problem we could add a callback function 3935 * to wlan_iflladdr() to be set optionally but that would be for a 3936 * single-consumer (or needs a list) -- was just too complicated for an 3937 * otherwise perfect mechanism FreeBSD already provides. 3938 */ 3939 static void 3940 lkpi_vif_iflladdr(void *arg, struct ifnet *ifp) 3941 { 3942 struct epoch_tracker et; 3943 struct ieee80211_vif *vif; 3944 3945 NET_EPOCH_ENTER(et); 3946 /* NB: identify vap's by if_transmit; left as an extra check. */ 3947 if (if_gettransmitfn(ifp) != ieee80211_vap_transmit || 3948 (if_getflags(ifp) & IFF_UP) != 0) { 3949 NET_EPOCH_EXIT(et); 3950 return; 3951 } 3952 3953 vif = arg; 3954 IEEE80211_ADDR_COPY(vif->bss_conf.addr, if_getlladdr(ifp)); 3955 NET_EPOCH_EXIT(et); 3956 } 3957 3958 static struct ieee80211vap * 3959 lkpi_ic_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], 3960 int unit, enum ieee80211_opmode opmode, int flags, 3961 const uint8_t bssid[IEEE80211_ADDR_LEN], 3962 const uint8_t mac[IEEE80211_ADDR_LEN]) 3963 { 3964 struct lkpi_hw *lhw; 3965 struct ieee80211_hw *hw; 3966 struct lkpi_vif *lvif; 3967 struct ieee80211vap *vap; 3968 struct ieee80211_vif *vif; 3969 struct ieee80211_tx_queue_params txqp; 3970 enum ieee80211_bss_changed changed; 3971 struct sysctl_oid *node; 3972 size_t len; 3973 int error, i; 3974 uint16_t ac; 3975 3976 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* 1 so far. Add <n> once this works. */ 3977 return (NULL); 3978 3979 lhw = ic->ic_softc; 3980 hw = LHW_TO_HW(lhw); 3981 3982 len = sizeof(*lvif); 3983 len += hw->vif_data_size; /* vif->drv_priv */ 3984 3985 lvif = malloc(len, M_80211_VAP, M_WAITOK | M_ZERO); 3986 mtx_init(&lvif->mtx, "lvif", NULL, MTX_DEF); 3987 TASK_INIT(&lvif->sw_scan_task, 0, lkpi_sw_scan_task, lvif); 3988 INIT_LIST_HEAD(&lvif->lsta_list); 3989 lvif->lvif_bss = NULL; 3990 refcount_init(&lvif->nt_unlocked, 0); 3991 lvif->lvif_bss_synched = false; 3992 vap = LVIF_TO_VAP(lvif); 3993 3994 vif = LVIF_TO_VIF(lvif); 3995 memcpy(vif->addr, mac, IEEE80211_ADDR_LEN); 3996 vif->p2p = false; 3997 vif->probe_req_reg = false; 3998 vif->type = lkpi_opmode_to_vif_type(opmode); 3999 lvif->wdev.iftype = vif->type; 4000 /* Need to fill in other fields as well. */ 4001 IMPROVE(); 4002 4003 /* XXX-BZ hardcoded for now! */ 4004 #if 1 4005 RCU_INIT_POINTER(vif->bss_conf.chanctx_conf, NULL); 4006 vif->bss_conf.vif = vif; 4007 /* vap->iv_myaddr is not set until net80211::vap_setup or vap_attach. */ 4008 IEEE80211_ADDR_COPY(vif->bss_conf.addr, mac); 4009 lvif->lvif_ifllevent = EVENTHANDLER_REGISTER(iflladdr_event, 4010 lkpi_vif_iflladdr, vif, EVENTHANDLER_PRI_ANY); 4011 vif->bss_conf.link_id = 0; /* Non-MLO operation. */ 4012 vif->bss_conf.chanreq.oper.width = NL80211_CHAN_WIDTH_20_NOHT; 4013 vif->bss_conf.use_short_preamble = false; /* vap->iv_flags IEEE80211_F_SHPREAMBLE */ 4014 vif->bss_conf.use_short_slot = false; /* vap->iv_flags IEEE80211_F_SHSLOT */ 4015 vif->bss_conf.qos = false; 4016 vif->bss_conf.use_cts_prot = false; /* vap->iv_protmode */ 4017 vif->bss_conf.ht_operation_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONE; 4018 vif->cfg.aid = 0; 4019 vif->cfg.assoc = false; 4020 vif->cfg.idle = true; 4021 vif->cfg.ps = false; 4022 IMPROVE("Check other fields and then figure out whats is left elsewhere of them"); 4023 /* 4024 * We need to initialize it to something as the bss_info_changed call 4025 * will try to copy from it in iwlwifi and NULL is a panic. 4026 * We will set the proper one in scan_to_auth() before being assoc. 4027 */ 4028 vif->bss_conf.bssid = ieee80211broadcastaddr; 4029 #endif 4030 #if 0 4031 vif->bss_conf.dtim_period = 0; /* IEEE80211_DTIM_DEFAULT ; must stay 0. */ 4032 IEEE80211_ADDR_COPY(vif->bss_conf.bssid, bssid); 4033 vif->bss_conf.beacon_int = ic->ic_bintval; 4034 /* iwlwifi bug. */ 4035 if (vif->bss_conf.beacon_int < 16) 4036 vif->bss_conf.beacon_int = 16; 4037 #endif 4038 4039 /* Link Config */ 4040 vif->link_conf[0] = &vif->bss_conf; 4041 for (i = 0; i < nitems(vif->link_conf); i++) { 4042 IMPROVE("more than 1 link one day"); 4043 } 4044 4045 /* Setup queue defaults; driver may override in (*add_interface). */ 4046 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 4047 if (ieee80211_hw_check(hw, QUEUE_CONTROL)) 4048 vif->hw_queue[i] = IEEE80211_INVAL_HW_QUEUE; 4049 else if (hw->queues >= IEEE80211_NUM_ACS) 4050 vif->hw_queue[i] = i; 4051 else 4052 vif->hw_queue[i] = 0; 4053 4054 /* Initialize the queue to running. Stopped? */ 4055 lvif->hw_queue_stopped[i] = false; 4056 } 4057 vif->cab_queue = IEEE80211_INVAL_HW_QUEUE; 4058 4059 IMPROVE(); 4060 4061 wiphy_lock(hw->wiphy); 4062 error = lkpi_80211_mo_start(hw); 4063 if (error != 0) { 4064 wiphy_unlock(hw->wiphy); 4065 ic_printf(ic, "%s: failed to start hw: %d\n", __func__, error); 4066 mtx_destroy(&lvif->mtx); 4067 free(lvif, M_80211_VAP); 4068 return (NULL); 4069 } 4070 4071 error = lkpi_80211_mo_add_interface(hw, vif); 4072 if (error != 0) { 4073 IMPROVE(); /* XXX-BZ mo_stop()? */ 4074 wiphy_unlock(hw->wiphy); 4075 ic_printf(ic, "%s: failed to add interface: %d\n", __func__, error); 4076 mtx_destroy(&lvif->mtx); 4077 free(lvif, M_80211_VAP); 4078 return (NULL); 4079 } 4080 wiphy_unlock(hw->wiphy); 4081 4082 LKPI_80211_LHW_LVIF_LOCK(lhw); 4083 TAILQ_INSERT_TAIL(&lhw->lvif_head, lvif, lvif_entry); 4084 LKPI_80211_LHW_LVIF_UNLOCK(lhw); 4085 4086 /* Set bss_info. */ 4087 changed = 0; 4088 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, changed); 4089 4090 /* Configure tx queues (conf_tx), default WME & send BSS_CHANGED_QOS. */ 4091 IMPROVE("Hardcoded values; to fix see 802.11-2016, 9.4.2.29 EDCA Parameter Set element"); 4092 wiphy_lock(hw->wiphy); 4093 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 4094 4095 bzero(&txqp, sizeof(txqp)); 4096 txqp.cw_min = 15; 4097 txqp.cw_max = 1023; 4098 txqp.txop = 0; 4099 txqp.aifs = 2; 4100 error = lkpi_80211_mo_conf_tx(hw, vif, /* link_id */0, ac, &txqp); 4101 if (error != 0) 4102 ic_printf(ic, "%s: conf_tx ac %u failed %d\n", 4103 __func__, ac, error); 4104 } 4105 wiphy_unlock(hw->wiphy); 4106 changed = BSS_CHANGED_QOS; 4107 lkpi_80211_mo_bss_info_changed(hw, vif, &vif->bss_conf, changed); 4108 4109 /* Force MC init. */ 4110 lkpi_update_mcast_filter(ic); 4111 4112 ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid); 4113 4114 /* Now we have a valid vap->iv_ifp. Any checksum offloading goes below. */ 4115 4116 IMPROVE(); 4117 4118 /* Override with LinuxKPI method so we can drive mac80211/cfg80211. */ 4119 lvif->iv_newstate = vap->iv_newstate; 4120 vap->iv_newstate = lkpi_iv_newstate; 4121 lvif->iv_update_bss = vap->iv_update_bss; 4122 vap->iv_update_bss = lkpi_iv_update_bss; 4123 lvif->iv_recv_mgmt = vap->iv_recv_mgmt; 4124 vap->iv_recv_mgmt = lkpi_iv_sta_recv_mgmt; 4125 4126 #ifdef LKPI_80211_HW_CRYPTO 4127 /* Key management. */ 4128 if (lkpi_hwcrypto && lhw->ops->set_key != NULL) { 4129 vap->iv_key_set = lkpi_iv_key_set; 4130 vap->iv_key_delete = lkpi_iv_key_delete; 4131 vap->iv_key_update_begin = lkpi_iv_key_update_begin; 4132 vap->iv_key_update_end = lkpi_iv_key_update_end; 4133 } 4134 #endif 4135 4136 #ifdef LKPI_80211_HT 4137 /* Stay with the iv_ampdu_rxmax,limit / iv_ampdu_density defaults until later. */ 4138 #endif 4139 4140 ieee80211_ratectl_init(vap); 4141 4142 /* Complete setup. */ 4143 ieee80211_vap_attach(vap, ieee80211_media_change, 4144 ieee80211_media_status, mac); 4145 4146 #ifdef LKPI_80211_HT 4147 /* 4148 * Modern chipset/fw/drv will do A-MPDU in drv/fw and fail 4149 * to do so if they cannot do the crypto too. 4150 */ 4151 if (!lkpi_hwcrypto && IEEE80211_CONF_AMPDU_OFFLOAD(ic)) 4152 vap->iv_flags_ht &= ~IEEE80211_FHT_AMPDU_RX; 4153 #endif 4154 4155 if (hw->max_listen_interval == 0) 4156 hw->max_listen_interval = 7 * (ic->ic_lintval / ic->ic_bintval); 4157 hw->conf.listen_interval = hw->max_listen_interval; 4158 ic->ic_set_channel(ic); 4159 4160 /* XXX-BZ do we need to be able to update these? */ 4161 hw->wiphy->frag_threshold = vap->iv_fragthreshold; 4162 lkpi_80211_mo_set_frag_threshold(hw, vap->iv_fragthreshold); 4163 hw->wiphy->rts_threshold = vap->iv_rtsthreshold; 4164 lkpi_80211_mo_set_rts_threshold(hw, vap->iv_rtsthreshold); 4165 /* any others? */ 4166 4167 /* Add per-VIF/VAP sysctls. */ 4168 sysctl_ctx_init(&lvif->sysctl_ctx); 4169 4170 node = SYSCTL_ADD_NODE(&lvif->sysctl_ctx, 4171 SYSCTL_CHILDREN(&sysctl___compat_linuxkpi_80211), 4172 OID_AUTO, if_name(vap->iv_ifp), 4173 CTLFLAG_RD | CTLFLAG_SKIP | CTLFLAG_MPSAFE, NULL, "VIF Information"); 4174 4175 SYSCTL_ADD_PROC(&lvif->sysctl_ctx, 4176 SYSCTL_CHILDREN(node), OID_AUTO, "dump_stas", 4177 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, lvif, 0, 4178 lkpi_80211_dump_stas, "A", "Dump sta statistics of this vif"); 4179 4180 IMPROVE(); 4181 4182 return (vap); 4183 } 4184 4185 void 4186 linuxkpi_ieee80211_unregister_hw(struct ieee80211_hw *hw) 4187 { 4188 4189 wiphy_unregister(hw->wiphy); 4190 linuxkpi_ieee80211_ifdetach(hw); 4191 4192 IMPROVE(); 4193 } 4194 4195 void 4196 linuxkpi_ieee80211_restart_hw(struct ieee80211_hw *hw) 4197 { 4198 4199 TODO(); 4200 } 4201 4202 static void 4203 lkpi_ic_vap_delete(struct ieee80211vap *vap) 4204 { 4205 struct ieee80211com *ic; 4206 struct lkpi_hw *lhw; 4207 struct ieee80211_hw *hw; 4208 struct lkpi_vif *lvif; 4209 struct ieee80211_vif *vif; 4210 4211 lvif = VAP_TO_LVIF(vap); 4212 vif = LVIF_TO_VIF(lvif); 4213 ic = vap->iv_ic; 4214 lhw = ic->ic_softc; 4215 hw = LHW_TO_HW(lhw); 4216 4217 EVENTHANDLER_DEREGISTER(iflladdr_event, lvif->lvif_ifllevent); 4218 4219 /* Clear up per-VIF/VAP sysctls. */ 4220 sysctl_ctx_free(&lvif->sysctl_ctx); 4221 4222 ieee80211_draintask(ic, &lvif->sw_scan_task); 4223 4224 LKPI_80211_LHW_LVIF_LOCK(lhw); 4225 TAILQ_REMOVE(&lhw->lvif_head, lvif, lvif_entry); 4226 LKPI_80211_LHW_LVIF_UNLOCK(lhw); 4227 4228 ieee80211_ratectl_deinit(vap); 4229 ieee80211_vap_detach(vap); 4230 4231 IMPROVE("clear up other bits in this state"); 4232 4233 lkpi_80211_mo_remove_interface(hw, vif); 4234 4235 /* Single VAP, so we can do this here. */ 4236 lkpi_80211_mo_stop(hw, false); /* XXX SUSPEND */ 4237 4238 mtx_destroy(&lvif->mtx); 4239 free(lvif, M_80211_VAP); 4240 } 4241 4242 static void 4243 lkpi_ic_update_mcast(struct ieee80211com *ic) 4244 { 4245 struct ieee80211vap *vap; 4246 struct lkpi_hw *lhw; 4247 4248 lhw = ic->ic_softc; 4249 if (lhw->ops->prepare_multicast == NULL || 4250 lhw->ops->configure_filter == NULL) 4251 return; 4252 4253 LKPI_80211_LHW_MC_LOCK(lhw); 4254 /* Cleanup anything on the current list. */ 4255 lkpi_cleanup_mcast_list_locked(lhw); 4256 4257 /* Build up the new list (or allmulti). */ 4258 if (ic->ic_allmulti == 0) { 4259 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 4260 if_foreach_llmaddr(vap->iv_ifp, 4261 lkpi_ic_update_mcast_copy, &lhw->mc_list); 4262 lhw->mc_all_multi = false; 4263 } else { 4264 lhw->mc_all_multi = true; 4265 } 4266 LKPI_80211_LHW_MC_UNLOCK(lhw); 4267 4268 lkpi_update_mcast_filter(ic); 4269 TRACEOK(); 4270 } 4271 4272 static void 4273 lkpi_ic_update_promisc(struct ieee80211com *ic) 4274 { 4275 4276 UNIMPLEMENTED; 4277 } 4278 4279 static void 4280 lkpi_ic_update_chw(struct ieee80211com *ic) 4281 { 4282 4283 UNIMPLEMENTED; 4284 } 4285 4286 /* Start / stop device. */ 4287 static void 4288 lkpi_ic_parent(struct ieee80211com *ic) 4289 { 4290 struct lkpi_hw *lhw; 4291 struct ieee80211_hw *hw; 4292 #ifdef HW_START_STOP 4293 int error; 4294 #endif 4295 bool start_all; 4296 4297 IMPROVE(); 4298 4299 lhw = ic->ic_softc; 4300 hw = LHW_TO_HW(lhw); 4301 start_all = false; 4302 4303 /* IEEE80211_UNLOCK(ic); */ 4304 wiphy_lock(hw->wiphy); 4305 if (ic->ic_nrunning > 0) { 4306 #ifdef HW_START_STOP 4307 error = lkpi_80211_mo_start(hw); 4308 if (error == 0) 4309 #endif 4310 start_all = true; 4311 } else { 4312 #ifdef HW_START_STOP 4313 lkpi_80211_mo_stop(hw, false); /* XXX SUSPEND */ 4314 #endif 4315 } 4316 wiphy_unlock(hw->wiphy); 4317 /* IEEE80211_LOCK(ic); */ 4318 4319 if (start_all) 4320 ieee80211_start_all(ic); 4321 } 4322 4323 bool 4324 linuxkpi_ieee80211_is_ie_id_in_ie_buf(const u8 ie, const u8 *ie_ids, 4325 size_t ie_ids_len) 4326 { 4327 int i; 4328 4329 for (i = 0; i < ie_ids_len; i++) { 4330 if (ie == *ie_ids) 4331 return (true); 4332 } 4333 4334 return (false); 4335 } 4336 4337 /* Return true if skipped; false if error. */ 4338 bool 4339 linuxkpi_ieee80211_ie_advance(size_t *xp, const u8 *ies, size_t ies_len) 4340 { 4341 size_t x; 4342 uint8_t l; 4343 4344 x = *xp; 4345 4346 KASSERT(x < ies_len, ("%s: x %zu ies_len %zu ies %p\n", 4347 __func__, x, ies_len, ies)); 4348 l = ies[x + 1]; 4349 x += 2 + l; 4350 4351 if (x > ies_len) 4352 return (false); 4353 4354 *xp = x; 4355 return (true); 4356 } 4357 4358 static uint8_t * 4359 lkpi_scan_ies_add(uint8_t *p, struct ieee80211_scan_ies *scan_ies, 4360 uint32_t band_mask, struct ieee80211vap *vap, struct ieee80211_hw *hw) 4361 { 4362 struct ieee80211_supported_band *supband; 4363 struct linuxkpi_ieee80211_channel *channels; 4364 struct ieee80211com *ic; 4365 const struct ieee80211_channel *chan; 4366 const struct ieee80211_rateset *rs; 4367 uint8_t *pb; 4368 int band, i; 4369 4370 ic = vap->iv_ic; 4371 for (band = 0; band < NUM_NL80211_BANDS; band++) { 4372 if ((band_mask & (1 << band)) == 0) 4373 continue; 4374 4375 supband = hw->wiphy->bands[band]; 4376 /* 4377 * This should not happen; 4378 * band_mask is a bitmask of valid bands to scan on. 4379 */ 4380 if (supband == NULL || supband->n_channels == 0) 4381 continue; 4382 4383 /* Find a first channel to get the mode and rates from. */ 4384 channels = supband->channels; 4385 chan = NULL; 4386 for (i = 0; i < supband->n_channels; i++) { 4387 uint32_t flags; 4388 4389 if (channels[i].flags & IEEE80211_CHAN_DISABLED) 4390 continue; 4391 4392 flags = 0; 4393 switch (band) { 4394 case NL80211_BAND_2GHZ: 4395 flags |= IEEE80211_CHAN_G; 4396 break; 4397 case NL80211_BAND_5GHZ: 4398 flags |= IEEE80211_CHAN_A; 4399 break; 4400 default: 4401 panic("%s:%d: unupported band %d\n", 4402 __func__, __LINE__, band); 4403 } 4404 4405 chan = ieee80211_find_channel(ic, 4406 channels[i].center_freq, flags); 4407 if (chan != NULL) 4408 break; 4409 } 4410 4411 /* This really should not happen. */ 4412 if (chan == NULL) 4413 continue; 4414 4415 pb = p; 4416 rs = ieee80211_get_suprates(ic, chan); /* calls chan2mode */ 4417 p = ieee80211_add_rates(p, rs); 4418 p = ieee80211_add_xrates(p, rs); 4419 4420 #if defined(LKPI_80211_HT) 4421 if ((vap->iv_flags_ht & IEEE80211_FHT_HT) != 0) { 4422 struct ieee80211_channel *c; 4423 4424 c = ieee80211_ht_adjust_channel(ic, ic->ic_curchan, 4425 vap->iv_flags_ht); 4426 p = ieee80211_add_htcap_ch(p, vap, c); 4427 } 4428 #endif 4429 #if defined(LKPI_80211_VHT) 4430 if (band == NL80211_BAND_5GHZ && 4431 (vap->iv_vht_flags & IEEE80211_FVHT_VHT) != 0) { 4432 struct ieee80211_channel *c; 4433 4434 c = ieee80211_ht_adjust_channel(ic, ic->ic_curchan, 4435 vap->iv_flags_ht); 4436 c = ieee80211_vht_adjust_channel(ic, c, 4437 vap->iv_vht_flags); 4438 p = ieee80211_add_vhtcap_ch(p, vap, c); 4439 } 4440 #endif 4441 4442 scan_ies->ies[band] = pb; 4443 scan_ies->len[band] = p - pb; 4444 } 4445 4446 /* Add common_ies */ 4447 pb = p; 4448 if ((vap->iv_flags & IEEE80211_F_WPA1) != 0 && 4449 vap->iv_wpa_ie != NULL) { 4450 memcpy(p, vap->iv_wpa_ie, 2 + vap->iv_wpa_ie[1]); 4451 p += 2 + vap->iv_wpa_ie[1]; 4452 } 4453 if (vap->iv_appie_probereq != NULL) { 4454 memcpy(p, vap->iv_appie_probereq->ie_data, 4455 vap->iv_appie_probereq->ie_len); 4456 p += vap->iv_appie_probereq->ie_len; 4457 } 4458 scan_ies->common_ies = pb; 4459 scan_ies->common_ie_len = p - pb; 4460 4461 return (p); 4462 } 4463 4464 static void 4465 lkpi_enable_hw_scan(struct lkpi_hw *lhw) 4466 { 4467 4468 if (lhw->ops->hw_scan) { 4469 /* 4470 * Advertise full-offload scanning. 4471 * 4472 * Not limiting to SINGLE_SCAN_ON_ALL_BANDS here as otherwise 4473 * we essentially disable hw_scan for all drivers not setting 4474 * the flag. 4475 */ 4476 lhw->ic->ic_flags_ext |= IEEE80211_FEXT_SCAN_OFFLOAD; 4477 lhw->scan_flags |= LKPI_LHW_SCAN_HW; 4478 } 4479 } 4480 4481 #ifndef LKPI_80211_USE_SCANLIST 4482 static const uint32_t chan_pri[] = { 4483 5180, 5500, 5745, 4484 5260, 5580, 5660, 5825, 4485 5220, 5300, 5540, 5620, 5700, 5785, 5865, 4486 2437, 2412, 2422, 2462, 2472, 2432, 2452 4487 }; 4488 4489 static int 4490 lkpi_scan_chan_list_idx(const struct linuxkpi_ieee80211_channel *lc) 4491 { 4492 int i; 4493 4494 for (i = 0; i < nitems(chan_pri); i++) { 4495 if (lc->center_freq == chan_pri[i]) 4496 return (i); 4497 } 4498 4499 return (-1); 4500 } 4501 4502 static int 4503 lkpi_scan_chan_list_comp(const struct linuxkpi_ieee80211_channel *lc1, 4504 const struct linuxkpi_ieee80211_channel *lc2) 4505 { 4506 int idx1, idx2; 4507 4508 /* Find index in list. */ 4509 idx1 = lkpi_scan_chan_list_idx(lc1); 4510 idx2 = lkpi_scan_chan_list_idx(lc2); 4511 4512 if (idx1 == -1 && idx2 != -1) 4513 return (1); 4514 if (idx1 != -1 && idx2 == -1) 4515 return (-1); 4516 4517 /* Neither on the list, use center_freq. */ 4518 if (idx1 == -1 && idx2 == -1) 4519 return (lc1->center_freq - lc2->center_freq); 4520 4521 /* Whichever is first in the list. */ 4522 return (idx1 - idx2); 4523 } 4524 4525 static void 4526 lkpi_scan_chan_list_resort(struct linuxkpi_ieee80211_channel **cpp, size_t nchan) 4527 { 4528 struct linuxkpi_ieee80211_channel *lc, *nc; 4529 size_t i, j; 4530 int rc; 4531 4532 for (i = (nchan - 1); i > 0; i--) { 4533 for (j = i; j > 0 ; j--) { 4534 lc = *(cpp + j); 4535 nc = *(cpp + j - 1); 4536 rc = lkpi_scan_chan_list_comp(lc, nc); 4537 if (rc < 0) { 4538 *(cpp + j) = nc; 4539 *(cpp + j - 1) = lc; 4540 } 4541 } 4542 } 4543 } 4544 4545 static bool 4546 lkpi_scan_chan(struct linuxkpi_ieee80211_channel *c, 4547 struct ieee80211com *ic, bool log) 4548 { 4549 4550 if ((c->flags & IEEE80211_CHAN_DISABLED) != 0) { 4551 if (log) 4552 TRACE_SCAN(ic, "Skipping disabled chan " 4553 "on band %s [%#x/%u/%#x]", 4554 lkpi_nl80211_band_name(c->band), c->hw_value, 4555 c->center_freq, c->flags); 4556 return (false); 4557 } 4558 if (isclr(ic->ic_chan_active, ieee80211_mhz2ieee(c->center_freq, 4559 lkpi_nl80211_band_to_net80211_band(c->band)))) { 4560 if (log) 4561 TRACE_SCAN(ic, "Skipping !active chan " 4562 "on band %s [%#x/%u/%#x]", 4563 lkpi_nl80211_band_name(c->band), c->hw_value, 4564 c->center_freq, c->flags); 4565 return (false); 4566 } 4567 return (true); 4568 } 4569 #endif 4570 4571 static void 4572 lkpi_ic_scan_start(struct ieee80211com *ic) 4573 { 4574 struct lkpi_hw *lhw; 4575 struct ieee80211_hw *hw; 4576 struct lkpi_vif *lvif; 4577 struct ieee80211_vif *vif; 4578 struct ieee80211_scan_state *ss; 4579 struct ieee80211vap *vap; 4580 int error; 4581 bool is_hw_scan; 4582 4583 lhw = ic->ic_softc; 4584 ss = ic->ic_scan; 4585 vap = ss->ss_vap; 4586 TRACE_SCAN(ic, "scan_flags %b", lhw->scan_flags, LKPI_LHW_SCAN_BITS); 4587 4588 LKPI_80211_LHW_SCAN_LOCK(lhw); 4589 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0) { 4590 /* A scan is still running. */ 4591 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 4592 TRACE_SCAN(ic, "Trying to start new scan while still running; " 4593 "cancelling new net80211 scan; scan_flags %b", 4594 lhw->scan_flags, LKPI_LHW_SCAN_BITS); 4595 ieee80211_cancel_scan(vap); 4596 return; 4597 } 4598 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0; 4599 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 4600 4601 #if 0 4602 if (vap->iv_state != IEEE80211_S_SCAN) { 4603 TODO("We need to be able to scan if not in S_SCAN"); 4604 TRACE_SCAN(ic, "scan_flags %b iv_state %d", 4605 lhw->scan_flags, LKPI_LHW_SCAN_BITS, vap->iv_state); 4606 ieee80211_cancel_scan(vap); 4607 return; 4608 } 4609 #endif 4610 4611 hw = LHW_TO_HW(lhw); 4612 if (!is_hw_scan) { 4613 /* If hw_scan is cleared clear FEXT_SCAN_OFFLOAD too. */ 4614 vap->iv_flags_ext &= ~IEEE80211_FEXT_SCAN_OFFLOAD; 4615 4616 lvif = VAP_TO_LVIF(vap); 4617 vif = LVIF_TO_VIF(lvif); 4618 4619 if (vap->iv_state == IEEE80211_S_SCAN) 4620 lkpi_hw_conf_idle(hw, false); 4621 4622 LKPI_80211_LHW_SCAN_LOCK(lhw); 4623 lhw->scan_flags |= LKPI_LHW_SCAN_RUNNING; 4624 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 4625 4626 lkpi_update_mcast_filter(ic); 4627 4628 TRACE_SCAN(vap->iv_ic, "Starting SW_SCAN: scan_flags %b", 4629 lhw->scan_flags, LKPI_LHW_SCAN_BITS); 4630 lkpi_80211_mo_sw_scan_start(hw, vif, vif->addr); 4631 /* net80211::scan_start() handled PS for us. */ 4632 IMPROVE(); 4633 /* XXX Also means it is too late to flush queues? 4634 * need to check iv_sta_ps or overload? */ 4635 /* XXX want to adjust ss end time/ maxdwell? */ 4636 4637 } else { 4638 struct ieee80211_scan_request *hw_req; 4639 struct linuxkpi_ieee80211_channel *lc, **cpp; 4640 struct cfg80211_ssid *ssids; 4641 struct cfg80211_scan_6ghz_params *s6gp; 4642 size_t chan_len, nchan, ssids_len, s6ghzlen; 4643 int band, i, ssid_count, common_ie_len; 4644 #ifndef LKPI_80211_USE_SCANLIST 4645 int n; 4646 #endif 4647 uint32_t band_mask; 4648 uint8_t *ie, *ieend; 4649 bool running; 4650 4651 ssid_count = min(ss->ss_nssid, hw->wiphy->max_scan_ssids); 4652 ssids_len = ssid_count * sizeof(*ssids); 4653 s6ghzlen = 0 * (sizeof(*s6gp)); /* XXX-BZ */ 4654 4655 band_mask = 0; 4656 nchan = 0; 4657 if (ieee80211_hw_check(hw, SINGLE_SCAN_ON_ALL_BANDS)) { 4658 #ifdef LKPI_80211_USE_SCANLIST 4659 /* Avoid net80211 scan lists until it has proper scan offload support. */ 4660 for (i = ss->ss_next; i < ss->ss_last; i++) { 4661 nchan++; 4662 band = lkpi_net80211_chan_to_nl80211_band( 4663 ss->ss_chans[ss->ss_next + i]); 4664 band_mask |= (1 << band); 4665 } 4666 #else 4667 /* Instead we scan for all channels all the time. */ 4668 for (band = 0; band < NUM_NL80211_BANDS; band++) { 4669 switch (band) { 4670 case NL80211_BAND_2GHZ: 4671 case NL80211_BAND_5GHZ: 4672 break; 4673 default: 4674 continue; 4675 } 4676 if (hw->wiphy->bands[band] != NULL) { 4677 struct linuxkpi_ieee80211_channel *channels; 4678 int n; 4679 4680 band_mask |= (1 << band); 4681 4682 channels = hw->wiphy->bands[band]->channels; 4683 n = hw->wiphy->bands[band]->n_channels; 4684 for (i = 0; i < n; i++) { 4685 if (lkpi_scan_chan(&channels[i], ic, true)) 4686 nchan++; 4687 } 4688 } 4689 } 4690 #endif 4691 } else { 4692 IMPROVE("individual band scans not yet supported, only scanning first band"); 4693 /* In theory net80211 should drive this. */ 4694 /* Probably we need to add local logic for now; 4695 * need to deal with scan_complete 4696 * and cancel_scan and keep local state. 4697 * Also cut the nchan down above. 4698 */ 4699 /* XXX-BZ ath10k does not set this but still does it? &$%^ */ 4700 } 4701 4702 chan_len = nchan * (sizeof(lc) + sizeof(*lc)); 4703 4704 common_ie_len = 0; 4705 if ((vap->iv_flags & IEEE80211_F_WPA1) != 0 && 4706 vap->iv_wpa_ie != NULL) 4707 common_ie_len += vap->iv_wpa_ie[1]; 4708 if (vap->iv_appie_probereq != NULL) 4709 common_ie_len += vap->iv_appie_probereq->ie_len; 4710 4711 /* We would love to check this at an earlier stage... */ 4712 if (common_ie_len > hw->wiphy->max_scan_ie_len) { 4713 ic_printf(ic, "WARNING: %s: common_ie_len %d > " 4714 "wiphy->max_scan_ie_len %d\n", __func__, 4715 common_ie_len, hw->wiphy->max_scan_ie_len); 4716 } 4717 4718 hw_req = malloc(sizeof(*hw_req) + ssids_len + 4719 s6ghzlen + chan_len + lhw->supbands * lhw->scan_ie_len + 4720 common_ie_len, M_LKPI80211, M_WAITOK | M_ZERO); 4721 4722 hw_req->req.flags = 0; /* XXX ??? */ 4723 /* hw_req->req.wdev */ 4724 hw_req->req.wiphy = hw->wiphy; 4725 hw_req->req.no_cck = false; /* XXX */ 4726 4727 /* 4728 * In general setting duration[_mandatory] seems to pessimise 4729 * default scanning behaviour. We only use it for BGSCANnig 4730 * to keep the dwell times small. 4731 * Setting duration_mandatory makes this the maximum dwell 4732 * time (otherwise may be shorter). Duration is in TU. 4733 */ 4734 if ((ic->ic_flags_ext & IEEE80211_FEXT_BGSCAN) != 0) { 4735 unsigned long dwell; 4736 4737 if ((ic->ic_caps & IEEE80211_C_BGSCAN) == 0 || 4738 (vap->iv_flags & IEEE80211_F_BGSCAN) == 0) 4739 ic_printf(ic, "BGSCAN despite off: %b, %b, %b\n", 4740 ic->ic_flags_ext, IEEE80211_FEXT_BITS, 4741 vap->iv_flags, IEEE80211_F_BITS, 4742 ic->ic_caps, IEEE80211_C_BITS); 4743 4744 dwell = ss->ss_mindwell; 4745 if (dwell == 0) 4746 dwell = msecs_to_ticks(20); 4747 4748 hw_req->req.duration_mandatory = true; 4749 hw_req->req.duration = TICKS_2_USEC(dwell) / 1024; 4750 } 4751 4752 #ifdef __notyet__ 4753 hw_req->req.flags |= NL80211_SCAN_FLAG_RANDOM_ADDR; 4754 memcpy(hw_req->req.mac_addr, xxx, IEEE80211_ADDR_LEN); 4755 memset(hw_req->req.mac_addr_mask, 0xxx, IEEE80211_ADDR_LEN); 4756 #endif 4757 eth_broadcast_addr(hw_req->req.bssid); 4758 4759 hw_req->req.n_channels = nchan; 4760 cpp = (struct linuxkpi_ieee80211_channel **)(hw_req + 1); 4761 lc = (struct linuxkpi_ieee80211_channel *)(cpp + nchan); 4762 #ifdef LKPI_80211_USE_SCANLIST 4763 for (i = 0; i < nchan; i++) { 4764 *(cpp + i) = 4765 (struct linuxkpi_ieee80211_channel *)(lc + i); 4766 } 4767 /* Avoid net80211 scan lists until it has proper scan offload support. */ 4768 for (i = 0; i < nchan; i++) { 4769 struct ieee80211_channel *c; 4770 4771 c = ss->ss_chans[ss->ss_next + i]; 4772 lc->center_freq = c->ic_freq; /* XXX */ 4773 /* lc->flags */ 4774 lc->band = lkpi_net80211_chan_to_nl80211_band(c); 4775 lc->max_power = c->ic_maxpower; 4776 /* lc-> ... */ 4777 lc++; 4778 } 4779 #else 4780 /* Add bands in reverse order for scanning. */ 4781 n = 0; 4782 for (band = NUM_NL80211_BANDS - 1; band >= 0; band--) { 4783 struct ieee80211_supported_band *supband; 4784 struct linuxkpi_ieee80211_channel *channels; 4785 4786 /* Band disabled for scanning? */ 4787 if ((band_mask & (1 << band)) == 0) 4788 continue; 4789 4790 /* Nothing to scan in band? */ 4791 supband = hw->wiphy->bands[band]; 4792 if (supband == NULL || supband->n_channels == 0) 4793 continue; 4794 4795 channels = supband->channels; 4796 for (i = 0; i < supband->n_channels; i++) { 4797 if (lkpi_scan_chan(&channels[i], ic, false)) 4798 *(cpp + n++) = &channels[i]; 4799 } 4800 } 4801 if (lkpi_order_scanlist) 4802 lkpi_scan_chan_list_resort(cpp, nchan); 4803 4804 if ((linuxkpi_debug_80211 & D80211_SCAN) != 0) { 4805 printf("%s:%d: %s SCAN Channel List (nchan=%zu): ", 4806 __func__, __LINE__, ic->ic_name, nchan); 4807 for (i = 0; i < nchan; i++) { 4808 struct linuxkpi_ieee80211_channel *xc; 4809 4810 xc = *(cpp + i); 4811 printf(" %d(%d)", 4812 ieee80211_mhz2ieee(xc->center_freq, 4813 lkpi_nl80211_band_to_net80211_band( 4814 xc->band)), 4815 xc->center_freq); 4816 } 4817 printf("\n"); 4818 } 4819 #endif 4820 4821 hw_req->req.n_ssids = ssid_count; 4822 if (hw_req->req.n_ssids > 0) { 4823 ssids = (struct cfg80211_ssid *)lc; 4824 hw_req->req.ssids = ssids; 4825 for (i = 0; i < ssid_count; i++) { 4826 ssids->ssid_len = ss->ss_ssid[i].len; 4827 memcpy(ssids->ssid, ss->ss_ssid[i].ssid, 4828 ss->ss_ssid[i].len); 4829 ssids++; 4830 } 4831 s6gp = (struct cfg80211_scan_6ghz_params *)ssids; 4832 } else { 4833 s6gp = (struct cfg80211_scan_6ghz_params *)lc; 4834 } 4835 4836 /* 6GHz one day. */ 4837 hw_req->req.n_6ghz_params = 0; 4838 hw_req->req.scan_6ghz_params = NULL; 4839 hw_req->req.scan_6ghz = false; /* Weird boolean; not what you think. */ 4840 /* s6gp->... */ 4841 4842 ie = ieend = (uint8_t *)s6gp; 4843 /* Copy per-band IEs, copy common IEs */ 4844 ieend = lkpi_scan_ies_add(ie, &hw_req->ies, band_mask, vap, hw); 4845 hw_req->req.ie = ie; 4846 hw_req->req.ie_len = ieend - ie; 4847 hw_req->req.scan_start = jiffies; 4848 4849 lvif = VAP_TO_LVIF(vap); 4850 vif = LVIF_TO_VIF(lvif); 4851 4852 LKPI_80211_LHW_SCAN_LOCK(lhw); 4853 /* Re-check under lock. */ 4854 running = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0; 4855 if (!running) { 4856 KASSERT(lhw->hw_req == NULL, ("%s: ic %p lhw %p hw_req %p " 4857 "!= NULL\n", __func__, ic, lhw, lhw->hw_req)); 4858 4859 lhw->scan_flags |= LKPI_LHW_SCAN_RUNNING; 4860 lhw->hw_req = hw_req; 4861 } 4862 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 4863 if (running) { 4864 free(hw_req, M_LKPI80211); 4865 TRACE_SCAN(ic, "Trying to start new scan while still " 4866 "running (2); cancelling new net80211 scan; " 4867 "scan_flags %b", 4868 lhw->scan_flags, LKPI_LHW_SCAN_BITS); 4869 ieee80211_cancel_scan(vap); 4870 return; 4871 } 4872 4873 lkpi_update_mcast_filter(ic); 4874 TRACE_SCAN(ic, "Starting HW_SCAN: scan_flags %b, " 4875 "ie_len %d, n_ssids %d, n_chan %d, common_ie_len %d [%d, %d]", 4876 lhw->scan_flags, LKPI_LHW_SCAN_BITS, hw_req->req.ie_len, 4877 hw_req->req.n_ssids, hw_req->req.n_channels, 4878 hw_req->ies.common_ie_len, 4879 hw_req->ies.len[NL80211_BAND_2GHZ], 4880 hw_req->ies.len[NL80211_BAND_5GHZ]); 4881 4882 error = lkpi_80211_mo_hw_scan(hw, vif, hw_req); 4883 if (error != 0) { 4884 bool scan_done; 4885 int e; 4886 4887 TRACE_SCAN(ic, "hw_scan failed; scan_flags %b, error %d", 4888 lhw->scan_flags, LKPI_LHW_SCAN_BITS, error); 4889 ieee80211_cancel_scan(vap); 4890 4891 /* 4892 * ieee80211_scan_completed must be called in either 4893 * case of error or none. So let the free happen there 4894 * and only there. 4895 * That would be fine in theory but in practice drivers 4896 * behave differently: 4897 * ath10k does not return hw_scan until after scan_complete 4898 * and can then still return an error. 4899 * rtw88 can return 1 or -EBUSY without scan_complete 4900 * iwlwifi can return various errors before scan starts 4901 * ... 4902 * So we cannot rely on that behaviour and have to check 4903 * and balance between both code paths. 4904 */ 4905 e = 0; 4906 scan_done = true; 4907 LKPI_80211_LHW_SCAN_LOCK(lhw); 4908 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0) { 4909 4910 free(lhw->hw_req, M_LKPI80211); 4911 lhw->hw_req = NULL; 4912 /* 4913 * The ieee80211_cancel_scan() above runs in a 4914 * taskq and it may take ages for the previous 4915 * scan to clear; starting a new one right away 4916 * we run into the problem that the old one is 4917 * still active. 4918 */ 4919 e = msleep(lhw, &lhw->scan_mtx, 0, "lhwscanstop", hz); 4920 scan_done = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0; 4921 4922 /* 4923 * Now we can clear running if no one else did. 4924 */ 4925 lhw->scan_flags &= ~LKPI_LHW_SCAN_RUNNING; 4926 } 4927 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 4928 lkpi_update_mcast_filter(ic); 4929 if (!scan_done) { 4930 ic_printf(ic, "ERROR: %s: timeout/error to wait " 4931 "for ieee80211_cancel_scan: %d\n", __func__, e); 4932 return; 4933 } 4934 4935 /* 4936 * XXX-SIGH magic number. 4937 * rtw88 has a magic "return 1" if offloading scan is 4938 * not possible. Fall back to sw scan in that case. 4939 */ 4940 if (error == 1) { 4941 /* 4942 * We need to put this into some defered context 4943 * the net80211 scan may not be done yet 4944 * (ic_flags & IEEE80211_F_SCAN) and we cannot 4945 * wait here; if we do scan_curchan_task always 4946 * runs after our timeout to finalize the scan. 4947 */ 4948 ieee80211_runtask(ic, &lvif->sw_scan_task); 4949 return; 4950 } 4951 4952 ic_printf(ic, "ERROR: %s: hw_scan returned %d\n", 4953 __func__, error); 4954 } 4955 } 4956 } 4957 4958 static void 4959 lkpi_sw_scan_task(void *arg, int pending __unused) 4960 { 4961 struct lkpi_hw *lhw; 4962 struct lkpi_vif *lvif; 4963 struct ieee80211vap *vap; 4964 struct ieee80211_scan_state *ss; 4965 4966 lvif = arg; 4967 vap = LVIF_TO_VAP(lvif); 4968 lhw = vap->iv_ic->ic_softc; 4969 ss = vap->iv_ic->ic_scan; 4970 4971 LKPI_80211_LHW_SCAN_LOCK(lhw); 4972 /* 4973 * We will re-enable this at scan_end calling lkpi_enable_hw_scan(). 4974 * IEEE80211_FEXT_SCAN_OFFLOAD will be cleared by lkpi_ic_scan_start. 4975 */ 4976 lhw->scan_flags &= ~LKPI_LHW_SCAN_HW; 4977 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 4978 4979 TRACE_SCAN(vap->iv_ic, "Triggering SW_SCAN: pending %d, scan_flags %b", 4980 pending, lhw->scan_flags, LKPI_LHW_SCAN_BITS); 4981 4982 /* 4983 * This will call ic_scan_start() and we will get into the right path 4984 * unless other scans started in between. 4985 */ 4986 ieee80211_start_scan(vap, 4987 IEEE80211_SCAN_ONCE, 4988 msecs_to_ticks(10000), /* 10000 ms (=~ 50 chan * 200 ms) */ 4989 ss->ss_mindwell ? ss->ss_mindwell : msecs_to_ticks(20), 4990 ss->ss_maxdwell ? ss->ss_maxdwell : msecs_to_ticks(200), 4991 vap->iv_des_nssid, vap->iv_des_ssid); 4992 } 4993 4994 static void 4995 lkpi_ic_scan_end(struct ieee80211com *ic) 4996 { 4997 struct lkpi_hw *lhw; 4998 bool is_hw_scan; 4999 5000 lhw = ic->ic_softc; 5001 TRACE_SCAN(ic, "scan_flags %b", lhw->scan_flags, LKPI_LHW_SCAN_BITS); 5002 5003 LKPI_80211_LHW_SCAN_LOCK(lhw); 5004 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) == 0) { 5005 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 5006 return; 5007 } 5008 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0; 5009 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 5010 5011 if (!is_hw_scan) { 5012 struct ieee80211_scan_state *ss; 5013 struct ieee80211vap *vap; 5014 struct ieee80211_hw *hw; 5015 struct lkpi_vif *lvif; 5016 struct ieee80211_vif *vif; 5017 5018 ss = ic->ic_scan; 5019 vap = ss->ss_vap; 5020 hw = LHW_TO_HW(lhw); 5021 lvif = VAP_TO_LVIF(vap); 5022 vif = LVIF_TO_VIF(lvif); 5023 5024 lkpi_80211_mo_sw_scan_complete(hw, vif); 5025 5026 /* Send PS to stop buffering if n80211 does not for us? */ 5027 5028 if (vap->iv_state == IEEE80211_S_SCAN) 5029 lkpi_hw_conf_idle(hw, true); 5030 } 5031 5032 /* 5033 * In case we disabled the hw_scan in lkpi_ic_scan_start() and 5034 * switched to swscan, re-enable hw_scan if available. 5035 */ 5036 lkpi_enable_hw_scan(lhw); 5037 5038 LKPI_80211_LHW_SCAN_LOCK(lhw); 5039 wakeup(lhw); 5040 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 5041 } 5042 5043 static void 5044 lkpi_ic_scan_curchan(struct ieee80211_scan_state *ss, 5045 unsigned long maxdwell) 5046 { 5047 struct lkpi_hw *lhw; 5048 bool is_hw_scan; 5049 5050 lhw = ss->ss_ic->ic_softc; 5051 TRACE_SCAN(ss->ss_ic, "scan_flags %b chan %d maxdwell %lu", 5052 lhw->scan_flags, LKPI_LHW_SCAN_BITS, 5053 ss->ss_ic->ic_curchan->ic_ieee, maxdwell); 5054 5055 LKPI_80211_LHW_SCAN_LOCK(lhw); 5056 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0; 5057 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 5058 if (!is_hw_scan) 5059 lhw->ic_scan_curchan(ss, maxdwell); 5060 } 5061 5062 static void 5063 lkpi_ic_scan_mindwell(struct ieee80211_scan_state *ss) 5064 { 5065 struct lkpi_hw *lhw; 5066 bool is_hw_scan; 5067 5068 lhw = ss->ss_ic->ic_softc; 5069 TRACE_SCAN(ss->ss_ic, "scan_flags %b chan %d mindwell %lu", 5070 lhw->scan_flags, LKPI_LHW_SCAN_BITS, 5071 ss->ss_ic->ic_curchan->ic_ieee, ss->ss_mindwell); 5072 5073 LKPI_80211_LHW_SCAN_LOCK(lhw); 5074 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0; 5075 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 5076 if (!is_hw_scan) 5077 lhw->ic_scan_mindwell(ss); 5078 } 5079 5080 static void 5081 lkpi_ic_set_channel(struct ieee80211com *ic) 5082 { 5083 struct lkpi_hw *lhw; 5084 struct ieee80211_hw *hw; 5085 struct ieee80211_channel *c; 5086 struct linuxkpi_ieee80211_channel *chan; 5087 int error; 5088 bool hw_scan_running; 5089 5090 lhw = ic->ic_softc; 5091 5092 /* If we do not support (*config)() save us the work. */ 5093 if (lhw->ops->config == NULL) 5094 return; 5095 5096 /* If we have a hw_scan running do not switch channels. */ 5097 LKPI_80211_LHW_SCAN_LOCK(lhw); 5098 hw_scan_running = 5099 (lhw->scan_flags & (LKPI_LHW_SCAN_RUNNING|LKPI_LHW_SCAN_HW)) == 5100 (LKPI_LHW_SCAN_RUNNING|LKPI_LHW_SCAN_HW); 5101 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 5102 if (hw_scan_running) 5103 return; 5104 5105 c = ic->ic_curchan; 5106 if (c == NULL || c == IEEE80211_CHAN_ANYC) { 5107 ic_printf(ic, "%s: c %p ops->config %p\n", __func__, 5108 c, lhw->ops->config); 5109 return; 5110 } 5111 5112 chan = lkpi_find_lkpi80211_chan(lhw, c); 5113 if (chan == NULL) { 5114 ic_printf(ic, "%s: c %p chan %p\n", __func__, 5115 c, chan); 5116 return; 5117 } 5118 5119 /* XXX max power for scanning? */ 5120 IMPROVE(); 5121 5122 hw = LHW_TO_HW(lhw); 5123 cfg80211_chandef_create(&hw->conf.chandef, chan, 5124 #ifdef LKPI_80211_HT 5125 (ic->ic_flags_ht & IEEE80211_FHT_HT) ? NL80211_CHAN_HT20 : 5126 #endif 5127 NL80211_CHAN_NO_HT); 5128 5129 error = lkpi_80211_mo_config(hw, IEEE80211_CONF_CHANGE_CHANNEL); 5130 if (error != 0 && error != EOPNOTSUPP) { 5131 ic_printf(ic, "ERROR: %s: config %#0x returned %d\n", 5132 __func__, IEEE80211_CONF_CHANGE_CHANNEL, error); 5133 /* XXX should we unroll to the previous chandef? */ 5134 IMPROVE(); 5135 } else { 5136 /* Update radiotap channels as well. */ 5137 lhw->rtap_tx.wt_chan_freq = htole16(c->ic_freq); 5138 lhw->rtap_tx.wt_chan_flags = htole16(c->ic_flags); 5139 lhw->rtap_rx.wr_chan_freq = htole16(c->ic_freq); 5140 lhw->rtap_rx.wr_chan_flags = htole16(c->ic_flags); 5141 } 5142 5143 /* Currently PS is hard coded off! Not sure it belongs here. */ 5144 IMPROVE(); 5145 if (ieee80211_hw_check(hw, SUPPORTS_PS) && 5146 (hw->conf.flags & IEEE80211_CONF_PS) != 0) { 5147 hw->conf.flags &= ~IEEE80211_CONF_PS; 5148 error = lkpi_80211_mo_config(hw, IEEE80211_CONF_CHANGE_PS); 5149 if (error != 0 && error != EOPNOTSUPP) 5150 ic_printf(ic, "ERROR: %s: config %#0x returned " 5151 "%d\n", __func__, IEEE80211_CONF_CHANGE_PS, 5152 error); 5153 } 5154 } 5155 5156 static struct ieee80211_node * 5157 lkpi_ic_node_alloc(struct ieee80211vap *vap, 5158 const uint8_t mac[IEEE80211_ADDR_LEN]) 5159 { 5160 struct ieee80211com *ic; 5161 struct lkpi_hw *lhw; 5162 struct ieee80211_node *ni; 5163 struct ieee80211_hw *hw; 5164 struct lkpi_sta *lsta; 5165 5166 ic = vap->iv_ic; 5167 lhw = ic->ic_softc; 5168 5169 /* We keep allocations de-coupled so we can deal with the two worlds. */ 5170 if (lhw->ic_node_alloc == NULL) 5171 return (NULL); 5172 5173 ni = lhw->ic_node_alloc(vap, mac); 5174 if (ni == NULL) 5175 return (NULL); 5176 5177 hw = LHW_TO_HW(lhw); 5178 lsta = lkpi_lsta_alloc(vap, mac, hw, ni); 5179 if (lsta == NULL) { 5180 if (lhw->ic_node_free != NULL) 5181 lhw->ic_node_free(ni); 5182 return (NULL); 5183 } 5184 5185 return (ni); 5186 } 5187 5188 static int 5189 lkpi_ic_node_init(struct ieee80211_node *ni) 5190 { 5191 struct ieee80211com *ic; 5192 struct lkpi_hw *lhw; 5193 int error; 5194 5195 ic = ni->ni_ic; 5196 lhw = ic->ic_softc; 5197 5198 if (lhw->ic_node_init != NULL) { 5199 error = lhw->ic_node_init(ni); 5200 if (error != 0) 5201 return (error); 5202 } 5203 5204 /* XXX-BZ Sync other state over. */ 5205 IMPROVE(); 5206 5207 return (0); 5208 } 5209 5210 static void 5211 lkpi_ic_node_cleanup(struct ieee80211_node *ni) 5212 { 5213 struct ieee80211com *ic; 5214 struct lkpi_hw *lhw; 5215 5216 ic = ni->ni_ic; 5217 lhw = ic->ic_softc; 5218 5219 /* XXX-BZ remove from driver, ... */ 5220 IMPROVE(); 5221 5222 if (lhw->ic_node_cleanup != NULL) 5223 lhw->ic_node_cleanup(ni); 5224 } 5225 5226 static void 5227 lkpi_ic_node_free(struct ieee80211_node *ni) 5228 { 5229 struct ieee80211com *ic; 5230 struct lkpi_hw *lhw; 5231 struct lkpi_sta *lsta; 5232 5233 ic = ni->ni_ic; 5234 lhw = ic->ic_softc; 5235 lsta = ni->ni_drv_data; 5236 5237 /* KASSERT lsta is not NULL here. Print ni/ni__refcnt. */ 5238 5239 /* 5240 * Pass in the original ni just in case of error we could check that 5241 * it is the same as lsta->ni. 5242 */ 5243 lkpi_lsta_free(lsta, ni); 5244 5245 if (lhw->ic_node_free != NULL) 5246 lhw->ic_node_free(ni); 5247 } 5248 5249 /* 5250 * lkpi_xmit() called from both the (*ic_raw_xmit) as well as the (*ic_transmit) 5251 * call path. 5252 * Unfortunately they have slightly different invariants. See 5253 * ieee80211_raw_output() and ieee80211_parent_xmitpkt(). 5254 * Both take care of the ni reference in case of error, and otherwise during 5255 * the callback after transmit. 5256 * The difference is that in case of error (*ic_raw_xmit) needs us to release 5257 * the mbuf, while (*ic_transmit) will free the mbuf itself. 5258 */ 5259 static int 5260 lkpi_xmit(struct ieee80211_node *ni, struct mbuf *m, 5261 const struct ieee80211_bpf_params *params __unused, 5262 bool freem) 5263 { 5264 struct lkpi_sta *lsta; 5265 int error; 5266 5267 lsta = ni->ni_drv_data; 5268 LKPI_80211_LSTA_TXQ_LOCK(lsta); 5269 #if 0 5270 if (!lsta->added_to_drv || !lsta->txq_ready) { 5271 #else 5272 /* 5273 * Backout this part of 886653492945f which breaks rtw88 or 5274 * in general drivers without (*sta_state)() but only the 5275 * legacy fallback to (*sta_add)(). 5276 */ 5277 if (!lsta->txq_ready) { 5278 #endif 5279 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 5280 if (freem) 5281 m_free(m); 5282 return (ENETDOWN); 5283 } 5284 5285 /* Queue the packet and enqueue the task to handle it. */ 5286 error = mbufq_enqueue(&lsta->txq, m); 5287 if (error != 0) { 5288 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 5289 if (freem) 5290 m_free(m); 5291 #ifdef LINUXKPI_DEBUG_80211 5292 if (linuxkpi_debug_80211 & D80211_TRACE_TX) 5293 ic_printf(ni->ni_ic, "%s: mbufq_enqueue failed: %d\n", 5294 __func__, error); 5295 #endif 5296 return (ENETDOWN); 5297 } 5298 taskqueue_enqueue(taskqueue_thread, &lsta->txq_task); 5299 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 5300 5301 #ifdef LINUXKPI_DEBUG_80211 5302 if (linuxkpi_debug_80211 & D80211_TRACE_TX) 5303 printf("%s:%d lsta %p ni %p %6D mbuf_qlen %d\n", 5304 __func__, __LINE__, lsta, ni, ni->ni_macaddr, ":", 5305 mbufq_len(&lsta->txq)); 5306 #endif 5307 5308 return (0); 5309 } 5310 5311 static int 5312 lkpi_ic_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 5313 const struct ieee80211_bpf_params *params __unused) 5314 { 5315 return (lkpi_xmit(ni, m, NULL, true)); 5316 } 5317 5318 #ifdef LKPI_80211_HW_CRYPTO 5319 /* 5320 * This is a bit of a hack given we know we are operating on a 5321 * single frame and we know that hardware will deal with it. 5322 * But otherwise the enmic bit and the encrypt bit need to be 5323 * decoupled. 5324 */ 5325 static int 5326 lkpi_hw_crypto_prepare_tkip(struct ieee80211_key *k, 5327 struct ieee80211_key_conf *kc, struct sk_buff *skb) 5328 { 5329 struct ieee80211_hdr *hdr; 5330 uint32_t hlen, hdrlen; 5331 uint8_t *p; 5332 5333 /* 5334 * TKIP only happens on data. 5335 */ 5336 hdr = (void *)skb->data; 5337 if (!ieee80211_is_data_present(hdr->frame_control)) 5338 return (0); 5339 5340 /* 5341 * "enmic" (though we do not do that). 5342 */ 5343 /* any conditions to not apply this? */ 5344 if (skb_tailroom(skb) < k->wk_cipher->ic_miclen) 5345 return (ENOBUFS); 5346 5347 p = skb_put(skb, k->wk_cipher->ic_miclen); 5348 if ((kc->flags & IEEE80211_KEY_FLAG_PUT_MIC_SPACE) != 0) 5349 goto encrypt; 5350 5351 /* 5352 * (*enmic) which we hopefully do not have to do with hw accel. 5353 * That means if we make it here we have a problem. 5354 */ 5355 TODO("(*enmic)"); 5356 return (ENXIO); 5357 5358 encrypt: 5359 /* 5360 * "encrypt" (though we do not do that). 5361 */ 5362 /* 5363 * Check if we have anything to do as requested by driver 5364 * or if we are done? 5365 */ 5366 if ((kc->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) == 0 && 5367 (kc->flags & IEEE80211_KEY_FLAG_GENERATE_IV) == 0) 5368 return (0); 5369 5370 hlen = k->wk_cipher->ic_header; 5371 if (skb_headroom(skb) < hlen) 5372 return (ENOBUFS); 5373 5374 hdr = (void *)skb->data; 5375 hdrlen = ieee80211_hdrlen(hdr->frame_control); 5376 p = skb_push(skb, hlen); 5377 memmove(p, p + hlen, hdrlen); 5378 5379 /* If driver request space only we are done. */ 5380 if ((kc->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) != 0) 5381 return (0); 5382 5383 p += hdrlen; 5384 k->wk_cipher->ic_setiv(k, p); 5385 5386 /* If we make it hear we do sw encryption. */ 5387 TODO("sw encrypt"); 5388 return (ENXIO); 5389 } 5390 5391 static int 5392 lkpi_hw_crypto_prepare_ccmp(struct ieee80211_key *k, 5393 struct ieee80211_key_conf *kc, struct sk_buff *skb) 5394 { 5395 struct ieee80211_hdr *hdr; 5396 uint32_t hlen, hdrlen; 5397 uint8_t *p; 5398 5399 hdr = (void *)skb->data; 5400 5401 /* 5402 * Check if we have anythig to do as requested by driver 5403 * or if we are done? 5404 */ 5405 if ((kc->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) == 0 && 5406 (kc->flags & IEEE80211_KEY_FLAG_GENERATE_IV) == 0 && 5407 /* MFP */ 5408 !((kc->flags & IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) != 0 && 5409 ieee80211_is_mgmt(hdr->frame_control))) 5410 return (0); 5411 5412 hlen = k->wk_cipher->ic_header; 5413 if (skb_headroom(skb) < hlen) 5414 return (ENOBUFS); 5415 5416 hdrlen = ieee80211_hdrlen(hdr->frame_control); 5417 p = skb_push(skb, hlen); 5418 memmove(p, p + hlen, hdrlen); 5419 5420 /* If driver request space only we are done. */ 5421 if ((kc->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) != 0) 5422 return (0); 5423 5424 p += hdrlen; 5425 k->wk_cipher->ic_setiv(k, p); 5426 5427 return (0); 5428 } 5429 5430 static int 5431 lkpi_hw_crypto_prepare(struct lkpi_sta *lsta, struct ieee80211_key *k, 5432 struct sk_buff *skb) 5433 { 5434 struct ieee80211_tx_info *info; 5435 struct ieee80211_key_conf *kc; 5436 5437 KASSERT(lsta != NULL, ("%s: lsta is NULL", __func__)); 5438 KASSERT(k != NULL, ("%s: key is NULL", __func__)); 5439 KASSERT(skb != NULL, ("%s: skb is NULL", __func__)); 5440 5441 kc = lsta->kc[k->wk_keyix]; 5442 5443 info = IEEE80211_SKB_CB(skb); 5444 info->control.hw_key = kc; 5445 5446 /* MUST NOT happen. KASSERT? */ 5447 if (kc == NULL) { 5448 ic_printf(lsta->ni->ni_ic, "%s: lsta %p k %p skb %p, " 5449 "kc is NULL on hw crypto offload\n", __func__, lsta, k, skb); 5450 return (ENXIO); 5451 } 5452 5453 switch (kc->cipher) { 5454 case WLAN_CIPHER_SUITE_TKIP: 5455 return (lkpi_hw_crypto_prepare_tkip(k, kc, skb)); 5456 case WLAN_CIPHER_SUITE_CCMP: 5457 return (lkpi_hw_crypto_prepare_ccmp(k, kc, skb)); 5458 case WLAN_CIPHER_SUITE_GCMP: 5459 return (lkpi_hw_crypto_prepare_ccmp(k, kc, skb)); 5460 case WLAN_CIPHER_SUITE_WEP40: 5461 case WLAN_CIPHER_SUITE_WEP104: 5462 case WLAN_CIPHER_SUITE_CCMP_256: 5463 case WLAN_CIPHER_SUITE_GCMP_256: 5464 case WLAN_CIPHER_SUITE_AES_CMAC: 5465 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 5466 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 5467 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 5468 default: 5469 ic_printf(lsta->ni->ni_ic, "%s: lsta %p k %p kc %p skb %p, " 5470 "unsupported cipher suite %u (%s)\n", __func__, lsta, k, kc, 5471 skb, kc->cipher, lkpi_cipher_suite_to_name(kc->cipher)); 5472 return (EOPNOTSUPP); 5473 } 5474 } 5475 5476 static uint8_t 5477 lkpi_hw_crypto_tailroom(struct lkpi_sta *lsta, struct ieee80211_key *k) 5478 { 5479 struct ieee80211_key_conf *kc; 5480 5481 kc = lsta->kc[k->wk_keyix]; 5482 if (kc == NULL) 5483 return (0); 5484 5485 IMPROVE("which other flags need tailroom?"); 5486 if (kc->flags & (IEEE80211_KEY_FLAG_PUT_MIC_SPACE)) 5487 return (32); /* Large enough to hold everything and pow2. */ 5488 5489 return (0); 5490 } 5491 #endif 5492 5493 static void 5494 lkpi_80211_txq_tx_one(struct lkpi_sta *lsta, struct mbuf *m) 5495 { 5496 struct ieee80211_node *ni; 5497 struct ieee80211_frame *wh; 5498 struct ieee80211_key *k; 5499 struct sk_buff *skb; 5500 struct ieee80211com *ic; 5501 struct lkpi_hw *lhw; 5502 struct ieee80211_hw *hw; 5503 struct lkpi_vif *lvif; 5504 struct ieee80211_vif *vif; 5505 struct ieee80211_channel *c; 5506 struct ieee80211_tx_control control; 5507 struct ieee80211_tx_info *info; 5508 struct ieee80211_sta *sta; 5509 struct ieee80211_hdr *hdr; 5510 struct lkpi_txq *ltxq; 5511 void *buf; 5512 ieee80211_keyix keyix; 5513 uint8_t ac, tid, tailroom; 5514 5515 M_ASSERTPKTHDR(m); 5516 #ifdef LINUXKPI_DEBUG_80211 5517 if (linuxkpi_debug_80211 & D80211_TRACE_TX_DUMP) 5518 hexdump(mtod(m, const void *), m->m_len, "RAW TX (plain) ", 0); 5519 #endif 5520 5521 ni = lsta->ni; 5522 k = NULL; 5523 keyix = IEEE80211_KEYIX_NONE; 5524 wh = mtod(m, struct ieee80211_frame *); 5525 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) { 5526 5527 #ifdef LKPI_80211_HW_CRYPTO 5528 if (lkpi_hwcrypto) { 5529 k = ieee80211_crypto_get_txkey(ni, m); 5530 if (k != NULL && lsta->kc[k->wk_keyix] != NULL) 5531 keyix = k->wk_keyix; 5532 } 5533 #endif 5534 5535 /* Encrypt the frame if need be. */ 5536 if (keyix == IEEE80211_KEYIX_NONE) { 5537 /* Retrieve key for TX && do software encryption. */ 5538 k = ieee80211_crypto_encap(ni, m); 5539 if (k == NULL) { 5540 ieee80211_free_node(ni); 5541 m_freem(m); 5542 return; 5543 } 5544 } 5545 } 5546 5547 ic = ni->ni_ic; 5548 lhw = ic->ic_softc; 5549 hw = LHW_TO_HW(lhw); 5550 c = ni->ni_chan; 5551 5552 if (ieee80211_radiotap_active_vap(ni->ni_vap)) { 5553 struct lkpi_radiotap_tx_hdr *rtap; 5554 5555 rtap = &lhw->rtap_tx; 5556 rtap->wt_flags = 0; 5557 if (k != NULL) 5558 rtap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 5559 if (m->m_flags & M_FRAG) 5560 rtap->wt_flags |= IEEE80211_RADIOTAP_F_FRAG; 5561 IMPROVE(); 5562 rtap->wt_rate = 0; 5563 if (c != NULL && c != IEEE80211_CHAN_ANYC) { 5564 rtap->wt_chan_freq = htole16(c->ic_freq); 5565 rtap->wt_chan_flags = htole16(c->ic_flags); 5566 } 5567 5568 ieee80211_radiotap_tx(ni->ni_vap, m); 5569 } 5570 5571 #ifdef LKPI_80211_HW_CRYPTO 5572 if (lkpi_hwcrypto && keyix != IEEE80211_KEYIX_NONE) 5573 tailroom = lkpi_hw_crypto_tailroom(lsta, k); 5574 else 5575 #endif 5576 tailroom = 0; 5577 5578 /* 5579 * net80211 should handle hw->extra_tx_headroom. 5580 * Though for as long as we are copying we don't mind. 5581 * XXX-BZ rtw88 asks for too much headroom for ipv6+tcp: 5582 * https://lists.freebsd.org/archives/freebsd-transport/2022-February/000012.html 5583 */ 5584 skb = dev_alloc_skb(hw->extra_tx_headroom + tailroom + m->m_pkthdr.len); 5585 if (skb == NULL) { 5586 static uint8_t skb_alloc_failures = 0; 5587 5588 if (skb_alloc_failures++ == 0) { 5589 int tid; 5590 5591 sta = LSTA_TO_STA(lsta); 5592 ic_printf(ic, "ERROR %s: skb alloc failed %d + %d, lsta %p sta %p ni %p\n", 5593 __func__, hw->extra_tx_headroom, m->m_pkthdr.len, lsta, sta, ni); 5594 for (tid = 0; tid < nitems(sta->txq); tid++) { 5595 if (sta->txq[tid] == NULL) 5596 continue; 5597 ltxq = TXQ_TO_LTXQ(sta->txq[tid]); 5598 ic_printf(ic, " tid %d ltxq %p seen_dequeue %d stopped %d skb_queue_len %u\n", 5599 tid, ltxq, ltxq->seen_dequeue, ltxq->stopped, skb_queue_len(<xq->skbq)); 5600 } 5601 } 5602 ieee80211_free_node(ni); 5603 m_freem(m); 5604 return; 5605 } 5606 skb_reserve(skb, hw->extra_tx_headroom); 5607 5608 /* XXX-BZ we need a SKB version understanding mbuf. */ 5609 /* Save the mbuf for ieee80211_tx_complete(). */ 5610 skb->m_free_func = lkpi_ieee80211_free_skb_mbuf; 5611 skb->m = m; 5612 #if 0 5613 skb_put_data(skb, m->m_data, m->m_pkthdr.len); 5614 #else 5615 buf = skb_put(skb, m->m_pkthdr.len); 5616 m_copydata(m, 0, m->m_pkthdr.len, buf); 5617 #endif 5618 /* Save the ni. */ 5619 m->m_pkthdr.PH_loc.ptr = ni; 5620 5621 lvif = VAP_TO_LVIF(ni->ni_vap); 5622 vif = LVIF_TO_VIF(lvif); 5623 5624 hdr = (void *)skb->data; 5625 tid = linuxkpi_ieee80211_get_tid(hdr, true); 5626 if (tid == IEEE80211_NONQOS_TID) { /* == IEEE80211_NUM_TIDS */ 5627 if (!ieee80211_is_data(hdr->frame_control)) { 5628 /* MGMT and CTRL frames go on TID 7/VO. */ 5629 skb->priority = 7; 5630 ac = IEEE80211_AC_VO; 5631 } else { 5632 /* Other non-QOS traffic goes to BE. */ 5633 /* Contrary to net80211 we MUST NOT promote M_EAPOL. */ 5634 skb->priority = 0; 5635 ac = IEEE80211_AC_BE; 5636 } 5637 } else { 5638 skb->priority = tid & IEEE80211_QOS_CTL_TID_MASK; 5639 ac = ieee80211e_up_to_ac[tid & 7]; 5640 } 5641 skb_set_queue_mapping(skb, ac); 5642 5643 info = IEEE80211_SKB_CB(skb); 5644 info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS; 5645 /* Slight delay; probably only happens on scanning so fine? */ 5646 if (c == NULL || c == IEEE80211_CHAN_ANYC) 5647 c = ic->ic_curchan; 5648 info->band = lkpi_net80211_chan_to_nl80211_band(c); 5649 info->hw_queue = vif->hw_queue[ac]; 5650 if (m->m_flags & M_EAPOL) 5651 info->control.flags |= IEEE80211_TX_CTRL_PORT_CTRL_PROTO; 5652 info->control.vif = vif; 5653 /* XXX-BZ info->control.rates */ 5654 #ifdef __notyet__ 5655 #ifdef LKPI_80211_HT 5656 info->control.rts_cts_rate_idx= 5657 info->control.use_rts= /* RTS */ 5658 info->control.use_cts_prot= /* RTS/CTS*/ 5659 #endif 5660 #endif 5661 5662 sta = LSTA_TO_STA(lsta); 5663 #ifdef LKPI_80211_HW_CRYPTO 5664 if (lkpi_hwcrypto && keyix != IEEE80211_KEYIX_NONE) { 5665 int error; 5666 5667 error = lkpi_hw_crypto_prepare(lsta, k, skb); 5668 if (error != 0) { 5669 /* 5670 * We only have to free the skb which will free the 5671 * mbuf and release the reference on the ni. 5672 */ 5673 dev_kfree_skb(skb); 5674 return; 5675 } 5676 } 5677 #endif 5678 5679 IMPROVE(); 5680 5681 ltxq = NULL; 5682 if (!ieee80211_is_data_present(hdr->frame_control)) { 5683 if (vif->type == NL80211_IFTYPE_STATION && 5684 lsta->added_to_drv && 5685 sta->txq[IEEE80211_NUM_TIDS] != NULL) 5686 ltxq = TXQ_TO_LTXQ(sta->txq[IEEE80211_NUM_TIDS]); 5687 } else if (lsta->added_to_drv && 5688 sta->txq[skb->priority] != NULL) { 5689 ltxq = TXQ_TO_LTXQ(sta->txq[skb->priority]); 5690 } 5691 if (ltxq == NULL) 5692 goto ops_tx; 5693 5694 KASSERT(ltxq != NULL, ("%s: lsta %p sta %p m %p skb %p " 5695 "ltxq %p != NULL\n", __func__, lsta, sta, m, skb, ltxq)); 5696 5697 LKPI_80211_LTXQ_LOCK(ltxq); 5698 skb_queue_tail(<xq->skbq, skb); 5699 #ifdef LINUXKPI_DEBUG_80211 5700 if (linuxkpi_debug_80211 & D80211_TRACE_TX) 5701 printf("%s:%d mo_wake_tx_queue :: %d %lu lsta %p sta %p " 5702 "ni %p %6D skb %p lxtq %p { qlen %u, ac %d tid %u } " 5703 "WAKE_TX_Q ac %d prio %u qmap %u\n", 5704 __func__, __LINE__, 5705 curthread->td_tid, jiffies, 5706 lsta, sta, ni, ni->ni_macaddr, ":", skb, ltxq, 5707 skb_queue_len(<xq->skbq), ltxq->txq.ac, 5708 ltxq->txq.tid, ac, skb->priority, skb->qmap); 5709 #endif 5710 LKPI_80211_LTXQ_UNLOCK(ltxq); 5711 wiphy_lock(hw->wiphy); 5712 lkpi_80211_mo_wake_tx_queue(hw, <xq->txq); 5713 wiphy_unlock(hw->wiphy); 5714 return; 5715 5716 ops_tx: 5717 #ifdef LINUXKPI_DEBUG_80211 5718 if (linuxkpi_debug_80211 & D80211_TRACE_TX) 5719 printf("%s:%d mo_tx :: lsta %p sta %p ni %p %6D skb %p " 5720 "TX ac %d prio %u qmap %u\n", 5721 __func__, __LINE__, lsta, sta, ni, ni->ni_macaddr, ":", 5722 skb, ac, skb->priority, skb->qmap); 5723 #endif 5724 memset(&control, 0, sizeof(control)); 5725 control.sta = sta; 5726 wiphy_lock(hw->wiphy); 5727 lkpi_80211_mo_tx(hw, &control, skb); 5728 wiphy_unlock(hw->wiphy); 5729 } 5730 5731 static void 5732 lkpi_80211_txq_task(void *ctx, int pending) 5733 { 5734 struct lkpi_sta *lsta; 5735 struct mbufq mq; 5736 struct mbuf *m; 5737 bool shall_tx; 5738 5739 lsta = ctx; 5740 5741 #ifdef LINUXKPI_DEBUG_80211 5742 if (linuxkpi_debug_80211 & D80211_TRACE_TX) 5743 printf("%s:%d lsta %p ni %p %6D pending %d mbuf_qlen %d\n", 5744 __func__, __LINE__, lsta, lsta->ni, lsta->ni->ni_macaddr, ":", 5745 pending, mbufq_len(&lsta->txq)); 5746 #endif 5747 5748 mbufq_init(&mq, IFQ_MAXLEN); 5749 5750 LKPI_80211_LSTA_TXQ_LOCK(lsta); 5751 /* 5752 * Do not re-check lsta->txq_ready here; we may have a pending 5753 * disassoc/deauth frame still. On the contrary if txq_ready is 5754 * false we do not have a valid sta anymore in the firmware so no 5755 * point to try to TX. 5756 * We also use txq_ready as a semaphore and will drain the txq manually 5757 * if needed on our way towards SCAN/INIT in the state machine. 5758 */ 5759 #if 0 5760 shall_tx = lsta->added_to_drv && lsta->txq_ready; 5761 #else 5762 /* 5763 * Backout this part of 886653492945f which breaks rtw88 or 5764 * in general drivers without (*sta_state)() but only the 5765 * legacy fallback to (*sta_add)(). 5766 */ 5767 shall_tx = lsta->txq_ready; 5768 #endif 5769 if (__predict_true(shall_tx)) 5770 mbufq_concat(&mq, &lsta->txq); 5771 /* 5772 * else a state change will push the packets out manually or 5773 * lkpi_lsta_free() will drain the lsta->txq and free the mbufs. 5774 */ 5775 LKPI_80211_LSTA_TXQ_UNLOCK(lsta); 5776 5777 m = mbufq_dequeue(&mq); 5778 while (m != NULL) { 5779 lkpi_80211_txq_tx_one(lsta, m); 5780 m = mbufq_dequeue(&mq); 5781 } 5782 } 5783 5784 static int 5785 lkpi_ic_transmit(struct ieee80211com *ic, struct mbuf *m) 5786 { 5787 5788 /* XXX TODO */ 5789 IMPROVE(); 5790 5791 /* Quick and dirty cheating hack. */ 5792 struct ieee80211_node *ni; 5793 5794 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 5795 return (lkpi_xmit(ni, m, NULL, false)); 5796 } 5797 5798 #ifdef LKPI_80211_HT 5799 static int 5800 lkpi_ic_recv_action(struct ieee80211_node *ni, const struct ieee80211_frame *wh, 5801 const uint8_t *frm, const uint8_t *efrm) 5802 { 5803 struct ieee80211com *ic; 5804 struct lkpi_hw *lhw; 5805 5806 ic = ni->ni_ic; 5807 lhw = ic->ic_softc; 5808 5809 IMPROVE_HT("recv_action called; nothing to do in lkpi; make debugging"); 5810 5811 return (lhw->ic_recv_action(ni, wh, frm, efrm)); 5812 } 5813 5814 static int 5815 lkpi_ic_send_action(struct ieee80211_node *ni, int category, int action, void *sa) 5816 { 5817 struct ieee80211com *ic; 5818 struct lkpi_hw *lhw; 5819 5820 ic = ni->ni_ic; 5821 lhw = ic->ic_softc; 5822 5823 IMPROVE_HT("send_action called; nothing to do in lkpi; make debugging"); 5824 5825 return (lhw->ic_send_action(ni, category, action, sa)); 5826 } 5827 5828 5829 static int 5830 lkpi_ic_ampdu_enable(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap) 5831 { 5832 struct ieee80211com *ic; 5833 struct lkpi_hw *lhw; 5834 5835 ic = ni->ni_ic; 5836 lhw = ic->ic_softc; 5837 5838 IMPROVE_HT("ieee80211_ampdu_enable called; nothing to do in lkpi for now; make debugging"); 5839 5840 return (lhw->ic_ampdu_enable(ni, tap)); 5841 } 5842 5843 /* 5844 * (*ic_addba_request)() is called by ieee80211_ampdu_request() before 5845 * calling send_action(CAT_BA, BA_ADDBA_REQUEST). 5846 * 5847 * NB: returns 0 on ERROR! 5848 */ 5849 static int 5850 lkpi_ic_addba_request(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap, 5851 int dialogtoken, int baparamset, int batimeout) 5852 { 5853 struct ieee80211com *ic; 5854 struct lkpi_hw *lhw; 5855 struct ieee80211_hw *hw; 5856 struct ieee80211vap *vap; 5857 struct lkpi_vif *lvif; 5858 struct ieee80211_vif *vif; 5859 struct lkpi_sta *lsta; 5860 struct ieee80211_sta *sta; 5861 struct ieee80211_ampdu_params params = { }; 5862 int error; 5863 5864 ic = ni->ni_ic; 5865 lhw = ic->ic_softc; 5866 hw = LHW_TO_HW(lhw); 5867 vap = ni->ni_vap; 5868 lvif = VAP_TO_LVIF(vap); 5869 vif = LVIF_TO_VIF(lvif); 5870 lsta = ni->ni_drv_data; 5871 sta = LSTA_TO_STA(lsta); 5872 5873 if (!lsta->added_to_drv) { 5874 ic_printf(ic, "%s: lsta %p ni %p, sta %p not added to firmware\n", 5875 __func__, lsta, ni, sta); 5876 return (0); 5877 } 5878 5879 params.sta = sta; 5880 params.action = IEEE80211_AMPDU_TX_START; 5881 /* Keep 0 here! */ 5882 params.buf_size = 0; 5883 params.timeout = 0; 5884 params.ssn = tap->txa_start & (IEEE80211_SEQ_RANGE-1); 5885 params.tid = tap->txa_tid; 5886 params.amsdu = false; 5887 5888 IEEE80211_UNLOCK(ic); 5889 wiphy_lock(hw->wiphy); 5890 error = lkpi_80211_mo_ampdu_action(hw, vif, ¶ms); 5891 wiphy_unlock(hw->wiphy); 5892 IEEE80211_LOCK(ic); 5893 if (error != 0) { 5894 ic_printf(ic, "%s: mo_ampdu_action returned %d. ni %p tap %p\n", 5895 __func__, error, ni, tap); 5896 return (0); 5897 } 5898 5899 return (lhw->ic_addba_request(ni, tap, dialogtoken, baparamset, batimeout)); 5900 } 5901 5902 /* 5903 * (*ic_addba_response)() is called from ht_recv_action_ba_addba_response() 5904 * and calls the default ieee80211_addba_response() which always returns 1. 5905 * 5906 * NB: No error checking in net80211! 5907 * Staying with 0 is an error. 5908 */ 5909 static int 5910 lkpi_ic_addba_response(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap, 5911 int status, int baparamset, int batimeout) 5912 { 5913 struct ieee80211com *ic; 5914 struct lkpi_hw *lhw; 5915 struct ieee80211_hw *hw; 5916 struct ieee80211vap *vap; 5917 struct lkpi_vif *lvif; 5918 struct ieee80211_vif *vif; 5919 struct lkpi_sta *lsta; 5920 struct ieee80211_sta *sta; 5921 struct ieee80211_ampdu_params params = { }; 5922 int error; 5923 5924 ic = ni->ni_ic; 5925 lhw = ic->ic_softc; 5926 hw = LHW_TO_HW(lhw); 5927 vap = ni->ni_vap; 5928 lvif = VAP_TO_LVIF(vap); 5929 vif = LVIF_TO_VIF(lvif); 5930 lsta = ni->ni_drv_data; 5931 sta = LSTA_TO_STA(lsta); 5932 5933 if (!lsta->added_to_drv) { 5934 ic_printf(ic, "%s: lsta %p ni %p, sta %p not added to firmware\n", 5935 __func__, lsta, ni, sta); 5936 return (0); 5937 } 5938 5939 if (status == IEEE80211_STATUS_SUCCESS) { 5940 params.sta = sta; 5941 params.action = IEEE80211_AMPDU_TX_OPERATIONAL; 5942 params.buf_size = tap->txa_wnd; 5943 params.timeout = 0; 5944 params.ssn = 0; 5945 params.tid = tap->txa_tid; 5946 if ((tap->txa_flags & IEEE80211_AGGR_AMSDU) != 0) 5947 params.amsdu = true; 5948 else 5949 params.amsdu = false; 5950 } else { 5951 /* We need to free the allocated resources. */ 5952 params.sta = sta; 5953 switch (status) { 5954 /* params.action = FLUSH, FLUSH_CONT */ 5955 default: 5956 params.action = IEEE80211_AMPDU_TX_STOP_CONT; 5957 break; 5958 } 5959 params.buf_size = 0; 5960 params.timeout = 0; 5961 params.ssn = 0; 5962 params.tid = tap->txa_tid; 5963 params.amsdu = false; 5964 } 5965 5966 IEEE80211_UNLOCK(ic); 5967 wiphy_lock(hw->wiphy); 5968 error = lkpi_80211_mo_ampdu_action(hw, vif, ¶ms); 5969 wiphy_unlock(hw->wiphy); 5970 IEEE80211_LOCK(ic); 5971 if (error != 0) { 5972 ic_printf(ic, "%s: mo_ampdu_action returned %d. ni %p tap %p\n", 5973 __func__, error, ni, tap); 5974 return (0); 5975 } 5976 5977 IMPROVE_HT("who unleashes the TXQ? and when?, do we need to ni->ni_txseqs[tid] = tap->txa_start & 0xfff;"); 5978 5979 return (lhw->ic_addba_response(ni, tap, status, baparamset, batimeout)); 5980 } 5981 5982 /* 5983 * (*ic_addba_stop)() is called from ampdu_tx_stop(), ht_recv_action_ba_delba(), 5984 * and ieee80211_ampdu_stop() and calls the default ieee80211_addba_stop(). 5985 */ 5986 static void 5987 lkpi_ic_addba_stop(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap) 5988 { 5989 struct ieee80211com *ic; 5990 struct lkpi_hw *lhw; 5991 struct ieee80211_hw *hw; 5992 struct ieee80211vap *vap; 5993 struct lkpi_vif *lvif; 5994 struct ieee80211_vif *vif; 5995 struct lkpi_sta *lsta; 5996 struct ieee80211_sta *sta; 5997 struct ieee80211_ampdu_params params = { }; 5998 int error; 5999 6000 ic = ni->ni_ic; 6001 lhw = ic->ic_softc; 6002 hw = LHW_TO_HW(lhw); 6003 vap = ni->ni_vap; 6004 lvif = VAP_TO_LVIF(vap); 6005 vif = LVIF_TO_VIF(lvif); 6006 lsta = ni->ni_drv_data; 6007 sta = LSTA_TO_STA(lsta); 6008 6009 if (!lsta->added_to_drv) { 6010 ic_printf(ic, "%s: lsta %p ni %p, sta %p not added to firmware\n", 6011 __func__, lsta, ni, sta); 6012 goto n80211; 6013 } 6014 6015 /* We need to free the allocated resources. */ 6016 params.sta = sta; 6017 IMPROVE("net80211 does not provide a reason to us"); 6018 params.action = IEEE80211_AMPDU_TX_STOP_CONT; /* params.action = FLUSH, FLUSH_CONT */ 6019 params.buf_size = 0; 6020 params.timeout = 0; 6021 params.ssn = 0; 6022 params.tid = tap->txa_tid; 6023 params.amsdu = false; 6024 6025 IEEE80211_UNLOCK(ic); 6026 wiphy_lock(hw->wiphy); 6027 error = lkpi_80211_mo_ampdu_action(hw, vif, ¶ms); 6028 wiphy_unlock(hw->wiphy); 6029 IEEE80211_LOCK(ic); 6030 if (error != 0) { 6031 ic_printf(ic, "%s: mo_ampdu_action returned %d. ni %p tap %p\n", 6032 __func__, error, ni, tap); 6033 goto n80211; 6034 } 6035 6036 IMPROVE_HT("anyting else?"); 6037 6038 n80211: 6039 lhw->ic_addba_stop(ni, tap); 6040 } 6041 6042 static void 6043 lkpi_ic_addba_response_timeout(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap) 6044 { 6045 struct ieee80211com *ic; 6046 struct lkpi_hw *lhw; 6047 6048 ic = ni->ni_ic; 6049 lhw = ic->ic_softc; 6050 6051 IMPROVE_HT(); 6052 6053 lhw->ic_addba_response_timeout(ni, tap); 6054 } 6055 6056 static void 6057 lkpi_ic_bar_response(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap, 6058 int status) 6059 { 6060 struct ieee80211com *ic; 6061 struct lkpi_hw *lhw; 6062 6063 ic = ni->ni_ic; 6064 lhw = ic->ic_softc; 6065 6066 IMPROVE_HT(); 6067 6068 lhw->ic_bar_response(ni, tap, status); 6069 } 6070 6071 static int 6072 lkpi_ic_ampdu_rx_start(struct ieee80211_node *ni, struct ieee80211_rx_ampdu *rap, 6073 int baparamset, int batimeout, int baseqctl) 6074 { 6075 struct ieee80211com *ic; 6076 struct lkpi_hw *lhw; 6077 struct ieee80211_hw *hw; 6078 struct ieee80211vap *vap; 6079 struct lkpi_vif *lvif; 6080 struct ieee80211_vif *vif; 6081 struct lkpi_sta *lsta; 6082 struct ieee80211_sta *sta; 6083 struct ieee80211_ampdu_params params = { }; 6084 int error; 6085 6086 ic = ni->ni_ic; 6087 lhw = ic->ic_softc; 6088 hw = LHW_TO_HW(lhw); 6089 vap = ni->ni_vap; 6090 lvif = VAP_TO_LVIF(vap); 6091 vif = LVIF_TO_VIF(lvif); 6092 lsta = ni->ni_drv_data; 6093 sta = LSTA_TO_STA(lsta); 6094 6095 IEEE80211_UNLOCK_ASSERT(ic); 6096 6097 if (!lsta->added_to_drv) { 6098 ic_printf(ic, "%s: lsta %p ni %p vap %p, sta %p not added to firmware\n", 6099 __func__, lsta, ni, vap, sta); 6100 return (-ENXIO); 6101 } 6102 6103 if (lsta->state != IEEE80211_STA_AUTHORIZED) { 6104 ic_printf(ic, "%s: lsta %p ni %p vap %p, sta %p state %d not AUTHORIZED\n", 6105 __func__, lsta, ni, vap, sta, lsta->state); 6106 return (-ENXIO); 6107 } 6108 6109 params.sta = sta; 6110 params.action = IEEE80211_AMPDU_RX_START; 6111 params.buf_size = _IEEE80211_MASKSHIFT(le16toh(baparamset), IEEE80211_BAPS_BUFSIZ); 6112 if (params.buf_size == 0) 6113 params.buf_size = IEEE80211_MAX_AMPDU_BUF_HT; 6114 else 6115 params.buf_size = min(params.buf_size, IEEE80211_MAX_AMPDU_BUF_HT); 6116 if (hw->max_rx_aggregation_subframes > 0 && 6117 params.buf_size > hw->max_rx_aggregation_subframes) 6118 params.buf_size = hw->max_rx_aggregation_subframes; 6119 params.timeout = le16toh(batimeout); 6120 params.ssn = _IEEE80211_MASKSHIFT(le16toh(baseqctl), IEEE80211_BASEQ_START); 6121 params.tid = _IEEE80211_MASKSHIFT(le16toh(baparamset), IEEE80211_BAPS_TID); 6122 6123 /* Based on net80211::ampdu_rx_start(). */ 6124 if ((vap->iv_htcaps & IEEE80211_HTC_RX_AMSDU_AMPDU) && 6125 (_IEEE80211_MASKSHIFT(baparamset, IEEE80211_BAPS_AMSDU))) 6126 params.amsdu = true; 6127 else 6128 params.amsdu = false; 6129 6130 wiphy_lock(hw->wiphy); 6131 error = lkpi_80211_mo_ampdu_action(hw, vif, ¶ms); 6132 wiphy_unlock(hw->wiphy); 6133 if (error != 0) { 6134 ic_printf(ic, "%s: mo_ampdu_action returned %d. ni %p rap %p\n", 6135 __func__, error, ni, rap); 6136 return (error); 6137 } 6138 6139 if (!ieee80211_hw_check(hw, SUPPORTS_REORDERING_BUFFER)) { 6140 IMPROVE("%s: TODO: SUPPORTS_REORDERING_BUFFER not set; check net80211\n", __func__); 6141 } 6142 6143 IMPROVE_HT("net80211 is missing the error check on return and assumes success"); 6144 6145 error = lhw->ic_ampdu_rx_start(ni, rap, baparamset, batimeout, baseqctl); 6146 return (error); 6147 } 6148 6149 static void 6150 lkpi_ic_ampdu_rx_stop(struct ieee80211_node *ni, struct ieee80211_rx_ampdu *rap) 6151 { 6152 struct ieee80211com *ic; 6153 struct lkpi_hw *lhw; 6154 struct ieee80211_hw *hw; 6155 struct ieee80211vap *vap; 6156 struct lkpi_vif *lvif; 6157 struct ieee80211_vif *vif; 6158 struct lkpi_sta *lsta; 6159 struct ieee80211_sta *sta; 6160 struct ieee80211_ampdu_params params = { }; 6161 int error; 6162 uint8_t tid; 6163 bool ic_locked; 6164 6165 ic = ni->ni_ic; 6166 lhw = ic->ic_softc; 6167 6168 /* 6169 * We should not (cannot) call into mac80211 ops with AMPDU_RX_STOP if 6170 * we did not START. Some drivers pass it down to firmware which will 6171 * simply barf and net80211 calls ieee80211_ht_node_cleanup() from 6172 * ieee80211_ht_node_init() amongst others which will iterate over all 6173 * tid and call ic_ampdu_rx_stop() unconditionally. 6174 * XXX net80211 should probably be more "gentle" in these cases and 6175 * track some state itself. 6176 */ 6177 if ((rap->rxa_flags & IEEE80211_AGGR_RUNNING) == 0) 6178 goto net80211_only; 6179 6180 hw = LHW_TO_HW(lhw); 6181 vap = ni->ni_vap; 6182 lvif = VAP_TO_LVIF(vap); 6183 vif = LVIF_TO_VIF(lvif); 6184 lsta = ni->ni_drv_data; 6185 if (lsta == NULL) { 6186 ic_printf(ic, "%s: lsta %p ni %p vap %p, lsta is NULL\n", 6187 __func__, lsta, ni, vap); 6188 goto net80211_only; 6189 } 6190 sta = LSTA_TO_STA(lsta); 6191 6192 if (!lsta->added_to_drv) { 6193 ic_printf(ic, "%s: lsta %p ni %p vap %p, sta %p not added to firmware\n", 6194 __func__, lsta, ni, vap, sta); 6195 goto net80211_only; 6196 } 6197 6198 if (lsta->state != IEEE80211_STA_AUTHORIZED) { 6199 ic_printf(ic, "%s: lsta %p ni %p vap %p, sta %p state %d not AUTHORIZED\n", 6200 __func__, lsta, ni, vap, sta, lsta->state); 6201 goto net80211_only; 6202 } 6203 6204 IMPROVE_HT("This really should be passed from ht_recv_action_ba_delba."); 6205 for (tid = 0; tid < WME_NUM_TID; tid++) { 6206 if (&ni->ni_rx_ampdu[tid] == rap) 6207 break; 6208 } 6209 if (tid == WME_NUM_TID) { 6210 ic_printf(ic, "%s: lsta %p ni %p vap %p, sta %p TID not found\n", 6211 __func__, lsta, ni, vap, sta); 6212 goto net80211_only; 6213 } 6214 6215 params.sta = sta; 6216 params.action = IEEE80211_AMPDU_RX_STOP; 6217 params.buf_size = 0; 6218 params.timeout = 0; 6219 params.ssn = 0; 6220 params.tid = tid; 6221 params.amsdu = false; 6222 6223 ic_locked = IEEE80211_IS_LOCKED(ic); 6224 if (ic_locked) 6225 IEEE80211_UNLOCK(ic); 6226 wiphy_lock(hw->wiphy); 6227 error = lkpi_80211_mo_ampdu_action(hw, vif, ¶ms); 6228 wiphy_unlock(hw->wiphy); 6229 if (ic_locked) 6230 IEEE80211_LOCK(ic); 6231 if (error != 0) 6232 ic_printf(ic, "%s: mo_ampdu_action returned %d. ni %p rap %p\n", 6233 __func__, error, ni, rap); 6234 6235 net80211_only: 6236 lhw->ic_ampdu_rx_stop(ni, rap); 6237 } 6238 #endif 6239 6240 static void 6241 lkpi_ic_getradiocaps_ht(struct ieee80211com *ic, struct ieee80211_hw *hw, 6242 uint8_t *bands, int *chan_flags, enum nl80211_band band) 6243 { 6244 #ifdef LKPI_80211_HT 6245 struct ieee80211_sta_ht_cap *ht_cap; 6246 6247 ht_cap = &hw->wiphy->bands[band]->ht_cap; 6248 if (!ht_cap->ht_supported) 6249 return; 6250 6251 switch (band) { 6252 case NL80211_BAND_2GHZ: 6253 setbit(bands, IEEE80211_MODE_11NG); 6254 break; 6255 case NL80211_BAND_5GHZ: 6256 setbit(bands, IEEE80211_MODE_11NA); 6257 break; 6258 default: 6259 IMPROVE("Unsupported band %d", band); 6260 return; 6261 } 6262 6263 ic->ic_htcaps = IEEE80211_HTC_HT; /* HT operation */ 6264 6265 /* 6266 * Rather than manually checking each flag and 6267 * translating IEEE80211_HT_CAP_ to IEEE80211_HTCAP_, 6268 * simply copy the 16bits. 6269 */ 6270 ic->ic_htcaps |= ht_cap->cap; 6271 6272 /* Then deal with the other flags. */ 6273 if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) 6274 ic->ic_htcaps |= IEEE80211_HTC_AMPDU; 6275 #ifdef __notyet__ 6276 if (ieee80211_hw_check(hw, TX_AMSDU)) 6277 ic->ic_htcaps |= IEEE80211_HTC_AMSDU; 6278 if (ieee80211_hw_check(hw, SUPPORTS_AMSDU_IN_AMPDU)) 6279 ic->ic_htcaps |= (IEEE80211_HTC_RX_AMSDU_AMPDU | 6280 IEEE80211_HTC_TX_AMSDU_AMPDU); 6281 #endif 6282 6283 IMPROVE("PS, ampdu_*, ht_cap.mcs.tx_params, ..."); 6284 6285 /* Only add HT40 channels if supported. */ 6286 if ((ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40) != 0 && 6287 chan_flags != NULL) 6288 *chan_flags |= NET80211_CBW_FLAG_HT40; 6289 #endif 6290 } 6291 6292 static void 6293 lkpi_ic_getradiocaps(struct ieee80211com *ic, int maxchan, 6294 int *n, struct ieee80211_channel *c) 6295 { 6296 struct lkpi_hw *lhw; 6297 struct ieee80211_hw *hw; 6298 struct linuxkpi_ieee80211_channel *channels; 6299 uint8_t bands[IEEE80211_MODE_BYTES]; 6300 int chan_flags, error, i, nchans; 6301 6302 /* Channels */ 6303 lhw = ic->ic_softc; 6304 hw = LHW_TO_HW(lhw); 6305 6306 /* NL80211_BAND_2GHZ */ 6307 nchans = 0; 6308 if (hw->wiphy->bands[NL80211_BAND_2GHZ] != NULL) 6309 nchans = hw->wiphy->bands[NL80211_BAND_2GHZ]->n_channels; 6310 if (nchans > 0) { 6311 memset(bands, 0, sizeof(bands)); 6312 chan_flags = 0; 6313 setbit(bands, IEEE80211_MODE_11B); 6314 /* XXX-BZ unclear how to check for 11g. */ 6315 6316 IMPROVE("the bitrates may have flags?"); 6317 setbit(bands, IEEE80211_MODE_11G); 6318 6319 lkpi_ic_getradiocaps_ht(ic, hw, bands, &chan_flags, 6320 NL80211_BAND_2GHZ); 6321 6322 channels = hw->wiphy->bands[NL80211_BAND_2GHZ]->channels; 6323 for (i = 0; i < nchans && *n < maxchan; i++) { 6324 uint32_t nflags = 0; 6325 int cflags = chan_flags; 6326 6327 if (channels[i].flags & IEEE80211_CHAN_DISABLED) { 6328 ic_printf(ic, "%s: Skipping disabled chan " 6329 "[%u/%u/%#x]\n", __func__, 6330 channels[i].hw_value, 6331 channels[i].center_freq, channels[i].flags); 6332 continue; 6333 } 6334 if (channels[i].flags & IEEE80211_CHAN_NO_IR) 6335 nflags |= (IEEE80211_CHAN_NOADHOC|IEEE80211_CHAN_PASSIVE); 6336 if (channels[i].flags & IEEE80211_CHAN_RADAR) 6337 nflags |= IEEE80211_CHAN_DFS; 6338 if (channels[i].flags & IEEE80211_CHAN_NO_160MHZ) 6339 cflags &= ~(NET80211_CBW_FLAG_VHT160|NET80211_CBW_FLAG_VHT80P80); 6340 if (channels[i].flags & IEEE80211_CHAN_NO_80MHZ) 6341 cflags &= ~NET80211_CBW_FLAG_VHT80; 6342 /* XXX how to map the remaining enum ieee80211_channel_flags? */ 6343 if (channels[i].flags & IEEE80211_CHAN_NO_HT40) 6344 cflags &= ~NET80211_CBW_FLAG_HT40; 6345 6346 error = ieee80211_add_channel_cbw(c, maxchan, n, 6347 ieee80211_mhz2ieee(channels[i].center_freq, 6348 lkpi_nl80211_band_to_net80211_band(channels[i].band)), 6349 channels[i].center_freq, channels[i].max_power, 6350 nflags, bands, cflags); 6351 /* net80211::ENOBUFS: *n >= maxchans */ 6352 if (error != 0 && error != ENOBUFS) 6353 ic_printf(ic, "%s: Adding chan %u/%u/%#x/%#x/%#x/%#x " 6354 "returned error %d\n", 6355 __func__, channels[i].hw_value, 6356 channels[i].center_freq, channels[i].flags, 6357 nflags, chan_flags, cflags, error); 6358 if (error != 0) 6359 break; 6360 } 6361 } 6362 6363 /* NL80211_BAND_5GHZ */ 6364 nchans = 0; 6365 if (hw->wiphy->bands[NL80211_BAND_5GHZ] != NULL) 6366 nchans = hw->wiphy->bands[NL80211_BAND_5GHZ]->n_channels; 6367 if (nchans > 0) { 6368 memset(bands, 0, sizeof(bands)); 6369 chan_flags = 0; 6370 setbit(bands, IEEE80211_MODE_11A); 6371 6372 lkpi_ic_getradiocaps_ht(ic, hw, bands, &chan_flags, 6373 NL80211_BAND_5GHZ); 6374 6375 #ifdef LKPI_80211_VHT 6376 if (hw->wiphy->bands[NL80211_BAND_5GHZ]->vht_cap.vht_supported) { 6377 6378 ic->ic_flags_ext |= IEEE80211_FEXT_VHT; 6379 ic->ic_vht_cap.vht_cap_info = 6380 hw->wiphy->bands[NL80211_BAND_5GHZ]->vht_cap.cap; 6381 ic->ic_vht_cap.supp_mcs = 6382 hw->wiphy->bands[NL80211_BAND_5GHZ]->vht_cap.vht_mcs; 6383 6384 setbit(bands, IEEE80211_MODE_VHT_5GHZ); 6385 chan_flags |= NET80211_CBW_FLAG_VHT80; 6386 if (IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_IS_160MHZ( 6387 ic->ic_vht_cap.vht_cap_info)) 6388 chan_flags |= NET80211_CBW_FLAG_VHT160; 6389 if (IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_IS_160_80P80MHZ( 6390 ic->ic_vht_cap.vht_cap_info)) 6391 chan_flags |= NET80211_CBW_FLAG_VHT80P80; 6392 } 6393 #endif 6394 6395 channels = hw->wiphy->bands[NL80211_BAND_5GHZ]->channels; 6396 for (i = 0; i < nchans && *n < maxchan; i++) { 6397 uint32_t nflags = 0; 6398 int cflags = chan_flags; 6399 6400 if (channels[i].flags & IEEE80211_CHAN_DISABLED) { 6401 ic_printf(ic, "%s: Skipping disabled chan " 6402 "[%u/%u/%#x]\n", __func__, 6403 channels[i].hw_value, 6404 channels[i].center_freq, channels[i].flags); 6405 continue; 6406 } 6407 if (channels[i].flags & IEEE80211_CHAN_NO_IR) 6408 nflags |= (IEEE80211_CHAN_NOADHOC|IEEE80211_CHAN_PASSIVE); 6409 if (channels[i].flags & IEEE80211_CHAN_RADAR) 6410 nflags |= IEEE80211_CHAN_DFS; 6411 if (channels[i].flags & IEEE80211_CHAN_NO_160MHZ) 6412 cflags &= ~(NET80211_CBW_FLAG_VHT160|NET80211_CBW_FLAG_VHT80P80); 6413 if (channels[i].flags & IEEE80211_CHAN_NO_80MHZ) 6414 cflags &= ~NET80211_CBW_FLAG_VHT80; 6415 /* XXX hwo to map the remaining enum ieee80211_channel_flags? */ 6416 if (channels[i].flags & IEEE80211_CHAN_NO_HT40) 6417 cflags &= ~NET80211_CBW_FLAG_HT40; 6418 6419 error = ieee80211_add_channel_cbw(c, maxchan, n, 6420 ieee80211_mhz2ieee(channels[i].center_freq, 6421 lkpi_nl80211_band_to_net80211_band(channels[i].band)), 6422 channels[i].center_freq, channels[i].max_power, 6423 nflags, bands, cflags); 6424 /* net80211::ENOBUFS: *n >= maxchans */ 6425 if (error != 0 && error != ENOBUFS) 6426 ic_printf(ic, "%s: Adding chan %u/%u/%#x/%#x/%#x/%#x " 6427 "returned error %d\n", 6428 __func__, channels[i].hw_value, 6429 channels[i].center_freq, channels[i].flags, 6430 nflags, chan_flags, cflags, error); 6431 if (error != 0) 6432 break; 6433 } 6434 } 6435 } 6436 6437 static void * 6438 lkpi_ieee80211_ifalloc(void) 6439 { 6440 struct ieee80211com *ic; 6441 6442 ic = malloc(sizeof(*ic), M_LKPI80211, M_WAITOK | M_ZERO); 6443 6444 /* Setting these happens later when we have device information. */ 6445 ic->ic_softc = NULL; 6446 ic->ic_name = "linuxkpi"; 6447 6448 return (ic); 6449 } 6450 6451 struct ieee80211_hw * 6452 linuxkpi_ieee80211_alloc_hw(size_t priv_len, const struct ieee80211_ops *ops) 6453 { 6454 struct ieee80211_hw *hw; 6455 struct lkpi_hw *lhw; 6456 struct wiphy *wiphy; 6457 int ac; 6458 6459 /* Get us and the driver data also allocated. */ 6460 wiphy = wiphy_new(&linuxkpi_mac80211cfgops, sizeof(*lhw) + priv_len); 6461 if (wiphy == NULL) 6462 return (NULL); 6463 6464 lhw = wiphy_priv(wiphy); 6465 lhw->ops = ops; 6466 6467 LKPI_80211_LHW_SCAN_LOCK_INIT(lhw); 6468 LKPI_80211_LHW_TXQ_LOCK_INIT(lhw); 6469 spin_lock_init(&lhw->txq_lock); 6470 sx_init_flags(&lhw->lvif_sx, "lhw-lvif", SX_RECURSE | SX_DUPOK); 6471 LKPI_80211_LHW_MC_LOCK_INIT(lhw); 6472 TAILQ_INIT(&lhw->lvif_head); 6473 __hw_addr_init(&lhw->mc_list); 6474 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 6475 spin_lock_init(&lhw->txq_scheduled_lock[ac]); 6476 lhw->txq_generation[ac] = 1; 6477 TAILQ_INIT(&lhw->txq_scheduled[ac]); 6478 } 6479 6480 /* Chanctx_conf */ 6481 INIT_LIST_HEAD(&lhw->lchanctx_list); 6482 6483 /* Deferred RX path. */ 6484 LKPI_80211_LHW_RXQ_LOCK_INIT(lhw); 6485 TASK_INIT(&lhw->rxq_task, 0, lkpi_80211_lhw_rxq_task, lhw); 6486 mbufq_init(&lhw->rxq, 32 * NAPI_POLL_WEIGHT); 6487 lhw->rxq_stopped = false; 6488 6489 /* 6490 * XXX-BZ TODO make sure there is a "_null" function to all ops 6491 * not initialized. 6492 */ 6493 hw = LHW_TO_HW(lhw); 6494 hw->wiphy = wiphy; 6495 hw->conf.flags |= IEEE80211_CONF_IDLE; 6496 hw->priv = (void *)(lhw + 1); 6497 6498 /* BSD Specific. */ 6499 lhw->ic = lkpi_ieee80211_ifalloc(); 6500 6501 IMPROVE(); 6502 6503 return (hw); 6504 } 6505 6506 void 6507 linuxkpi_ieee80211_iffree(struct ieee80211_hw *hw) 6508 { 6509 struct lkpi_hw *lhw; 6510 struct mbuf *m; 6511 int ac; 6512 6513 lhw = HW_TO_LHW(hw); 6514 free(lhw->ic, M_LKPI80211); 6515 lhw->ic = NULL; 6516 6517 /* 6518 * Drain the deferred RX path. 6519 */ 6520 LKPI_80211_LHW_RXQ_LOCK(lhw); 6521 lhw->rxq_stopped = true; 6522 LKPI_80211_LHW_RXQ_UNLOCK(lhw); 6523 6524 /* Drain taskq, won't be restarted due to rxq_stopped being set. */ 6525 while (taskqueue_cancel(taskqueue_thread, &lhw->rxq_task, NULL) != 0) 6526 taskqueue_drain(taskqueue_thread, &lhw->rxq_task); 6527 6528 /* Flush mbufq (make sure to release ni refs!). */ 6529 m = mbufq_dequeue(&lhw->rxq); 6530 while (m != NULL) { 6531 #ifdef LKPI_80211_USE_MTAG 6532 struct m_tag *mtag; 6533 6534 mtag = m_tag_locate(m, MTAG_ABI_LKPI80211, LKPI80211_TAG_RXNI, NULL); 6535 if (mtag != NULL) { 6536 struct lkpi_80211_tag_rxni *rxni; 6537 6538 rxni = (struct lkpi_80211_tag_rxni *)(mtag + 1); 6539 ieee80211_free_node(rxni->ni); 6540 } 6541 #else 6542 if (m->m_pkthdr.PH_loc.ptr != NULL) { 6543 struct ieee80211_node *ni; 6544 6545 ni = m->m_pkthdr.PH_loc.ptr; 6546 ieee80211_free_node(ni); 6547 } 6548 #endif 6549 m_freem(m); 6550 m = mbufq_dequeue(&lhw->rxq); 6551 } 6552 KASSERT(mbufq_empty(&lhw->rxq), ("%s: lhw %p has rxq len %d != 0\n", 6553 __func__, lhw, mbufq_len(&lhw->rxq))); 6554 LKPI_80211_LHW_RXQ_LOCK_DESTROY(lhw); 6555 6556 /* Chanctx_conf. */ 6557 if (!list_empty_careful(&lhw->lchanctx_list)) { 6558 struct lkpi_chanctx *lchanctx, *next; 6559 struct ieee80211_chanctx_conf *chanctx_conf; 6560 6561 list_for_each_entry_safe(lchanctx, next, &lhw->lchanctx_list, entry) { 6562 if (lchanctx->added_to_drv) { 6563 /* In reality we should panic? */ 6564 chanctx_conf = &lchanctx->chanctx_conf; 6565 lkpi_80211_mo_remove_chanctx(hw, chanctx_conf); 6566 } 6567 list_del(&lchanctx->entry); 6568 free(lchanctx, M_LKPI80211); 6569 } 6570 } 6571 6572 LKPI_80211_LHW_MC_LOCK(lhw); 6573 lkpi_cleanup_mcast_list_locked(lhw); 6574 LKPI_80211_LHW_MC_UNLOCK(lhw); 6575 6576 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) 6577 spin_lock_destroy(&lhw->txq_scheduled_lock[ac]); 6578 6579 /* Cleanup more of lhw here or in wiphy_free()? */ 6580 spin_lock_destroy(&lhw->txq_lock); 6581 LKPI_80211_LHW_TXQ_LOCK_DESTROY(lhw); 6582 LKPI_80211_LHW_SCAN_LOCK_DESTROY(lhw); 6583 sx_destroy(&lhw->lvif_sx); 6584 LKPI_80211_LHW_MC_LOCK_DESTROY(lhw) 6585 IMPROVE(); 6586 } 6587 6588 void 6589 linuxkpi_set_ieee80211_dev(struct ieee80211_hw *hw) 6590 { 6591 struct lkpi_hw *lhw; 6592 struct ieee80211com *ic; 6593 struct device *dev; 6594 6595 lhw = HW_TO_LHW(hw); 6596 ic = lhw->ic; 6597 6598 /* Save the backpointer from net80211 to LinuxKPI. */ 6599 ic->ic_softc = lhw; 6600 6601 /* 6602 * Set a proper name before ieee80211_ifattach() if dev is set. 6603 * ath1xk also unset the dev so we need to check. 6604 */ 6605 dev = wiphy_dev(hw->wiphy); 6606 if (dev != NULL) { 6607 ic->ic_name = dev_name(dev); 6608 } else { 6609 TODO("adjust arguments to still have the old dev or go through " 6610 "the hoops of getting the bsddev from hw and detach; " 6611 "or do in XXX; check ath1kx drivers"); 6612 } 6613 6614 /* XXX-BZ do we also need to set wiphy name? */ 6615 } 6616 6617 struct ieee80211_hw * 6618 linuxkpi_wiphy_to_ieee80211_hw(struct wiphy *wiphy) 6619 { 6620 struct lkpi_hw *lhw; 6621 6622 lhw = wiphy_priv(wiphy); 6623 return (LHW_TO_HW(lhw)); 6624 } 6625 6626 static void 6627 lkpi_radiotap_attach(struct lkpi_hw *lhw) 6628 { 6629 struct ieee80211com *ic; 6630 6631 ic = lhw->ic; 6632 ieee80211_radiotap_attach(ic, 6633 &lhw->rtap_tx.wt_ihdr, sizeof(lhw->rtap_tx), 6634 LKPI_RTAP_TX_FLAGS_PRESENT, 6635 &lhw->rtap_rx.wr_ihdr, sizeof(lhw->rtap_rx), 6636 LKPI_RTAP_RX_FLAGS_PRESENT); 6637 } 6638 6639 int 6640 linuxkpi_ieee80211_ifattach(struct ieee80211_hw *hw) 6641 { 6642 struct ieee80211com *ic; 6643 struct lkpi_hw *lhw; 6644 int band, i; 6645 6646 lhw = HW_TO_LHW(hw); 6647 ic = lhw->ic; 6648 6649 /* We do it this late as wiphy->dev should be set for the name. */ 6650 lhw->workq = alloc_ordered_workqueue(wiphy_name(hw->wiphy), 0); 6651 if (lhw->workq == NULL) 6652 return (-EAGAIN); 6653 6654 /* XXX-BZ figure this out how they count his... */ 6655 if (!is_zero_ether_addr(hw->wiphy->perm_addr)) { 6656 IEEE80211_ADDR_COPY(ic->ic_macaddr, 6657 hw->wiphy->perm_addr); 6658 } else if (hw->wiphy->n_addresses > 0) { 6659 /* We take the first one. */ 6660 IEEE80211_ADDR_COPY(ic->ic_macaddr, 6661 hw->wiphy->addresses[0].addr); 6662 } else { 6663 ic_printf(ic, "%s: warning, no hardware address!\n", __func__); 6664 } 6665 6666 #ifdef __not_yet__ 6667 /* See comment in lkpi_80211_txq_tx_one(). */ 6668 ic->ic_headroom = hw->extra_tx_headroom; 6669 #endif 6670 6671 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 6672 ic->ic_opmode = IEEE80211_M_STA; 6673 6674 /* Set device capabilities. */ 6675 /* XXX-BZ we need to get these from linux80211/drivers and convert. */ 6676 ic->ic_caps = 6677 IEEE80211_C_STA | 6678 IEEE80211_C_MONITOR | 6679 IEEE80211_C_WPA | /* WPA/RSN */ 6680 #ifdef LKPI_80211_WME 6681 IEEE80211_C_WME | 6682 #endif 6683 #if 0 6684 IEEE80211_C_PMGT | 6685 #endif 6686 IEEE80211_C_SHSLOT | /* short slot time supported */ 6687 IEEE80211_C_SHPREAMBLE /* short preamble supported */ 6688 ; 6689 6690 #ifdef LKPI_80211_BGSCAN 6691 if (lhw->ops->hw_scan) 6692 ic->ic_caps |= IEEE80211_C_BGSCAN; 6693 #endif 6694 6695 lkpi_enable_hw_scan(lhw); 6696 6697 /* Does HW support Fragmentation offload? */ 6698 if (ieee80211_hw_check(hw, SUPPORTS_TX_FRAG)) 6699 ic->ic_flags_ext |= IEEE80211_FEXT_FRAG_OFFLOAD; 6700 6701 /* Does HW support full AMPDU[-TX] offload? */ 6702 if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) 6703 ic->ic_flags_ext |= IEEE80211_FEXT_AMPDU_OFFLOAD; 6704 #ifdef __notyet__ 6705 if (ieee80211_hw_check(hw, TX_AMSDU)) 6706 if (ieee80211_hw_check(hw, SUPPORTS_AMSDU_IN_AMPDU)) 6707 #endif 6708 6709 /* 6710 * The wiphy variables report bitmasks of avail antennas. 6711 * (*get_antenna) get the current bitmask sets which can be 6712 * altered by (*set_antenna) for some drivers. 6713 * XXX-BZ will the count alone do us much good long-term in net80211? 6714 */ 6715 if (hw->wiphy->available_antennas_rx || 6716 hw->wiphy->available_antennas_tx) { 6717 uint32_t rxs, txs; 6718 6719 if (lkpi_80211_mo_get_antenna(hw, &txs, &rxs) == 0) { 6720 ic->ic_rxstream = bitcount32(rxs); 6721 ic->ic_txstream = bitcount32(txs); 6722 } 6723 } 6724 6725 ic->ic_cryptocaps = 0; 6726 #ifdef LKPI_80211_HW_CRYPTO 6727 if (lkpi_hwcrypto && hw->wiphy->n_cipher_suites > 0) { 6728 uint32_t hwciphers; 6729 6730 hwciphers = 0; 6731 for (i = 0; i < hw->wiphy->n_cipher_suites; i++) { 6732 uint32_t cs; 6733 6734 cs = lkpi_l80211_to_net80211_cyphers( 6735 ic, hw->wiphy->cipher_suites[i]); 6736 if (cs == IEEE80211_CRYPTO_TKIP) { 6737 /* 6738 * We do set this here. We will only find out 6739 * when doing a SET_KEY operation depending on 6740 * what the driver returns. 6741 * net80211::ieee80211_crypto_newkey() 6742 * checks this so we will have to do flags 6743 * surgery later. 6744 */ 6745 cs |= IEEE80211_CRYPTO_TKIPMIC; 6746 } 6747 hwciphers |= cs; 6748 } 6749 /* 6750 * (20250415) nothing anywhere in the path checks we actually 6751 * support all these in net80211. 6752 * net80211 supports _256 variants but the ioctl does not. 6753 */ 6754 IMPROVE("as net80211 grows more support, enable them"); 6755 hwciphers &= (IEEE80211_CRYPTO_WEP | 6756 IEEE80211_CRYPTO_TKIP | IEEE80211_CRYPTO_TKIPMIC | 6757 IEEE80211_CRYPTO_AES_CCM | IEEE80211_CRYPTO_AES_GCM_128); 6758 /* 6759 * We only support CCMP here, so further filter. 6760 * Also permit TKIP if turned on. 6761 */ 6762 hwciphers &= (IEEE80211_CRYPTO_AES_CCM | 6763 IEEE80211_CRYPTO_AES_GCM_128 | 6764 (lkpi_hwcrypto_tkip ? (IEEE80211_CRYPTO_TKIP | 6765 IEEE80211_CRYPTO_TKIPMIC) : 0)); 6766 ieee80211_set_hardware_ciphers(ic, hwciphers); 6767 } 6768 #endif 6769 6770 lkpi_ic_getradiocaps(ic, IEEE80211_CHAN_MAX, &ic->ic_nchans, 6771 ic->ic_channels); 6772 6773 ieee80211_ifattach(ic); 6774 6775 ic->ic_update_mcast = lkpi_ic_update_mcast; 6776 ic->ic_update_promisc = lkpi_ic_update_promisc; 6777 ic->ic_update_chw = lkpi_ic_update_chw; 6778 ic->ic_parent = lkpi_ic_parent; 6779 ic->ic_scan_start = lkpi_ic_scan_start; 6780 ic->ic_scan_end = lkpi_ic_scan_end; 6781 ic->ic_set_channel = lkpi_ic_set_channel; 6782 ic->ic_transmit = lkpi_ic_transmit; 6783 ic->ic_raw_xmit = lkpi_ic_raw_xmit; 6784 ic->ic_vap_create = lkpi_ic_vap_create; 6785 ic->ic_vap_delete = lkpi_ic_vap_delete; 6786 ic->ic_getradiocaps = lkpi_ic_getradiocaps; 6787 ic->ic_wme.wme_update = lkpi_ic_wme_update; 6788 6789 lhw->ic_scan_curchan = ic->ic_scan_curchan; 6790 ic->ic_scan_curchan = lkpi_ic_scan_curchan; 6791 lhw->ic_scan_mindwell = ic->ic_scan_mindwell; 6792 ic->ic_scan_mindwell = lkpi_ic_scan_mindwell; 6793 6794 lhw->ic_node_alloc = ic->ic_node_alloc; 6795 ic->ic_node_alloc = lkpi_ic_node_alloc; 6796 lhw->ic_node_init = ic->ic_node_init; 6797 ic->ic_node_init = lkpi_ic_node_init; 6798 lhw->ic_node_cleanup = ic->ic_node_cleanup; 6799 ic->ic_node_cleanup = lkpi_ic_node_cleanup; 6800 lhw->ic_node_free = ic->ic_node_free; 6801 ic->ic_node_free = lkpi_ic_node_free; 6802 6803 #ifdef LKPI_80211_HT 6804 /* 6805 * Only attach if the driver/firmware supports (*ampdu_action)(). 6806 * Otherwise it is in the hands of net80211. 6807 */ 6808 if (lhw->ops->ampdu_action != NULL) { 6809 lhw->ic_recv_action = ic->ic_recv_action; 6810 ic->ic_recv_action = lkpi_ic_recv_action; 6811 lhw->ic_send_action = ic->ic_send_action; 6812 ic->ic_send_action = lkpi_ic_send_action; 6813 6814 lhw->ic_ampdu_enable = ic->ic_ampdu_enable; 6815 ic->ic_ampdu_enable = lkpi_ic_ampdu_enable; 6816 6817 lhw->ic_addba_request = ic->ic_addba_request; 6818 ic->ic_addba_request = lkpi_ic_addba_request; 6819 lhw->ic_addba_response = ic->ic_addba_response; 6820 ic->ic_addba_response = lkpi_ic_addba_response; 6821 lhw->ic_addba_stop = ic->ic_addba_stop; 6822 ic->ic_addba_stop = lkpi_ic_addba_stop; 6823 lhw->ic_addba_response_timeout = ic->ic_addba_response_timeout; 6824 ic->ic_addba_response_timeout = lkpi_ic_addba_response_timeout; 6825 6826 lhw->ic_bar_response = ic->ic_bar_response; 6827 ic->ic_bar_response = lkpi_ic_bar_response; 6828 6829 lhw->ic_ampdu_rx_start = ic->ic_ampdu_rx_start; 6830 ic->ic_ampdu_rx_start = lkpi_ic_ampdu_rx_start; 6831 lhw->ic_ampdu_rx_stop = ic->ic_ampdu_rx_stop; 6832 ic->ic_ampdu_rx_stop = lkpi_ic_ampdu_rx_stop; 6833 } 6834 #endif 6835 6836 lkpi_radiotap_attach(lhw); 6837 6838 /* 6839 * Assign the first possible channel for now; seems Realtek drivers 6840 * expect one. 6841 * Also remember the amount of bands we support and the most rates 6842 * in any band so we can scale [(ext) sup rates] IE(s) accordingly. 6843 */ 6844 lhw->supbands = lhw->max_rates = 0; 6845 for (band = 0; band < NUM_NL80211_BANDS; band++) { 6846 struct ieee80211_supported_band *supband; 6847 struct linuxkpi_ieee80211_channel *channels; 6848 6849 supband = hw->wiphy->bands[band]; 6850 if (supband == NULL || supband->n_channels == 0) 6851 continue; 6852 6853 lhw->supbands++; 6854 lhw->max_rates = max(lhw->max_rates, supband->n_bitrates); 6855 6856 /* If we have a channel, we need to keep counting supbands. */ 6857 if (hw->conf.chandef.chan != NULL) 6858 continue; 6859 6860 channels = supband->channels; 6861 for (i = 0; i < supband->n_channels; i++) { 6862 6863 if (channels[i].flags & IEEE80211_CHAN_DISABLED) 6864 continue; 6865 6866 cfg80211_chandef_create(&hw->conf.chandef, &channels[i], 6867 #ifdef LKPI_80211_HT 6868 (ic->ic_flags_ht & IEEE80211_FHT_HT) ? NL80211_CHAN_HT20 : 6869 #endif 6870 NL80211_CHAN_NO_HT); 6871 break; 6872 } 6873 } 6874 6875 IMPROVE("see net80211::ieee80211_chan_init vs. wiphy->bands[].bitrates possibly in lkpi_ic_getradiocaps?"); 6876 6877 /* Make sure we do not support more than net80211 is willing to take. */ 6878 if (lhw->max_rates > IEEE80211_RATE_MAXSIZE) { 6879 ic_printf(ic, "%s: limiting max_rates %d to %d!\n", __func__, 6880 lhw->max_rates, IEEE80211_RATE_MAXSIZE); 6881 lhw->max_rates = IEEE80211_RATE_MAXSIZE; 6882 } 6883 6884 /* 6885 * The maximum supported bitrates on any band + size for 6886 * DSSS Parameter Set give our per-band IE size. 6887 * SSID is the responsibility of the driver and goes on the side. 6888 * The user specified bits coming from the vap go into the 6889 * "common ies" fields. 6890 */ 6891 lhw->scan_ie_len = 2 + IEEE80211_RATE_SIZE; 6892 if (lhw->max_rates > IEEE80211_RATE_SIZE) 6893 lhw->scan_ie_len += 2 + (lhw->max_rates - IEEE80211_RATE_SIZE); 6894 6895 if (hw->wiphy->features & NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) { 6896 /* 6897 * net80211 does not seem to support the DSSS Parameter Set but 6898 * some of the drivers insert it so calculate the extra fixed 6899 * space in. 6900 */ 6901 lhw->scan_ie_len += 2 + 1; 6902 } 6903 6904 #if defined(LKPI_80211_HT) 6905 if ((ic->ic_htcaps & IEEE80211_HTC_HT) != 0) 6906 lhw->scan_ie_len += sizeof(struct ieee80211_ie_htcap); 6907 #endif 6908 #if defined(LKPI_80211_VHT) 6909 if (IEEE80211_CONF_VHT(ic)) 6910 lhw->scan_ie_len += 2 + sizeof(struct ieee80211_vht_cap); 6911 #endif 6912 6913 /* Reduce the max_scan_ie_len "left" by the amount we consume already. */ 6914 if (hw->wiphy->max_scan_ie_len > 0) { 6915 if (lhw->scan_ie_len > hw->wiphy->max_scan_ie_len) 6916 goto err; 6917 hw->wiphy->max_scan_ie_len -= lhw->scan_ie_len; 6918 } 6919 6920 if (bootverbose) { 6921 ic_printf(ic, "netdev_features %b\n", hw->netdev_features, NETIF_F_BITS); 6922 ieee80211_announce(ic); 6923 } 6924 6925 return (0); 6926 err: 6927 IMPROVE("TODO FIXME CLEANUP"); 6928 return (-EAGAIN); 6929 } 6930 6931 void 6932 linuxkpi_ieee80211_ifdetach(struct ieee80211_hw *hw) 6933 { 6934 struct lkpi_hw *lhw; 6935 struct ieee80211com *ic; 6936 6937 lhw = HW_TO_LHW(hw); 6938 ic = lhw->ic; 6939 ieee80211_ifdetach(ic); 6940 } 6941 6942 void 6943 linuxkpi_ieee80211_iterate_interfaces(struct ieee80211_hw *hw, 6944 enum ieee80211_iface_iter flags, 6945 void(*iterfunc)(void *, uint8_t *, struct ieee80211_vif *), 6946 void *arg) 6947 { 6948 struct lkpi_hw *lhw; 6949 struct lkpi_vif *lvif; 6950 struct ieee80211_vif *vif; 6951 bool active, atomic, nin_drv; 6952 6953 lhw = HW_TO_LHW(hw); 6954 6955 if (flags & ~(IEEE80211_IFACE_ITER_NORMAL| 6956 IEEE80211_IFACE_ITER_RESUME_ALL| 6957 IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER| 6958 IEEE80211_IFACE_ITER_ACTIVE|IEEE80211_IFACE_ITER__ATOMIC| 6959 IEEE80211_IFACE_ITER__MTX)) { 6960 ic_printf(lhw->ic, "XXX TODO %s flags(%#x) not yet supported.\n", 6961 __func__, flags); 6962 } 6963 6964 if ((flags & IEEE80211_IFACE_ITER__MTX) != 0) 6965 lockdep_assert_wiphy(hw->wiphy); 6966 6967 active = (flags & IEEE80211_IFACE_ITER_ACTIVE) != 0; 6968 atomic = (flags & IEEE80211_IFACE_ITER__ATOMIC) != 0; 6969 nin_drv = (flags & IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER) != 0; 6970 6971 if (atomic) { 6972 IMPROVE("LKPI_80211_LHW_LVIF_LOCK atomic assume to be rcu?"); 6973 LKPI_80211_LHW_LVIF_LOCK(lhw); 6974 } 6975 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) { 6976 struct ieee80211vap *vap; 6977 6978 vif = LVIF_TO_VIF(lvif); 6979 6980 /* 6981 * If we want "active" interfaces, we need to distinguish on 6982 * whether the driver knows about them or not to be able to 6983 * handle the "resume" case correctly. Skip the ones the 6984 * driver does not know about. 6985 */ 6986 if (active && !lvif->added_to_drv && 6987 (flags & IEEE80211_IFACE_ITER_RESUME_ALL) != 0) 6988 continue; 6989 6990 /* 6991 * If we shall skip interfaces not added to the driver do so 6992 * if we haven't yet. 6993 */ 6994 if (nin_drv && !lvif->added_to_drv) 6995 continue; 6996 6997 /* 6998 * Run the iterator function if we are either not asking 6999 * asking for active only or if the VAP is "running". 7000 */ 7001 /* XXX-BZ probably should have state in the lvif as well. */ 7002 vap = LVIF_TO_VAP(lvif); 7003 if (!active || (vap->iv_state != IEEE80211_S_INIT)) 7004 iterfunc(arg, vif->addr, vif); 7005 } 7006 if (atomic) 7007 LKPI_80211_LHW_LVIF_UNLOCK(lhw); 7008 } 7009 7010 static void 7011 lkpi_ieee80211_iterate_keys(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 7012 ieee80211_keyix keyix, struct lkpi_sta *lsta, 7013 void(*iterfunc)(struct ieee80211_hw *, struct ieee80211_vif *, 7014 struct ieee80211_sta *, struct ieee80211_key_conf *, void *), 7015 void *arg) 7016 { 7017 if (!lsta->added_to_drv) 7018 return; 7019 7020 if (lsta->kc[keyix] == NULL) 7021 return; 7022 7023 iterfunc(hw, vif, LSTA_TO_STA(lsta), lsta->kc[keyix], arg); 7024 } 7025 7026 void 7027 linuxkpi_ieee80211_iterate_keys(struct ieee80211_hw *hw, 7028 struct ieee80211_vif *vif, 7029 void(*iterfunc)(struct ieee80211_hw *, struct ieee80211_vif *, 7030 struct ieee80211_sta *, struct ieee80211_key_conf *, void *), 7031 void *arg, bool rcu) 7032 { 7033 struct lkpi_sta *lsta; 7034 struct lkpi_vif *lvif; 7035 7036 lvif = VIF_TO_LVIF(vif); 7037 7038 if (rcu) { 7039 rcu_read_lock_held(); /* XXX-BZ is this correct? */ 7040 7041 if (vif == NULL) { 7042 TODO(); 7043 } else { 7044 list_for_each_entry_rcu(lsta, &lvif->lsta_list, lsta_list) { 7045 for (ieee80211_keyix keyix = 0; keyix < nitems(lsta->kc); 7046 keyix++) 7047 lkpi_ieee80211_iterate_keys(hw, vif, 7048 keyix, lsta, iterfunc, arg); 7049 } 7050 } 7051 } else { 7052 TODO("Used by suspend/resume; order of keys as installed to " 7053 "firmware is important; we'll need to rewrite some code for that"); 7054 lockdep_assert_wiphy(hw->wiphy); 7055 7056 if (vif == NULL) { 7057 TODO(); 7058 } else { 7059 list_for_each_entry(lsta, &lvif->lsta_list, lsta_list) { 7060 for (ieee80211_keyix keyix = 0; keyix < nitems(lsta->kc); 7061 keyix++) 7062 lkpi_ieee80211_iterate_keys(hw, vif, 7063 keyix, lsta, iterfunc, arg); 7064 } 7065 } 7066 } 7067 } 7068 7069 void 7070 linuxkpi_ieee80211_iterate_chan_contexts(struct ieee80211_hw *hw, 7071 void(*iterfunc)(struct ieee80211_hw *, struct ieee80211_chanctx_conf *, 7072 void *), 7073 void *arg) 7074 { 7075 struct lkpi_hw *lhw; 7076 struct lkpi_chanctx *lchanctx; 7077 7078 KASSERT(hw != NULL && iterfunc != NULL, 7079 ("%s: hw %p iterfunc %p arg %p\n", __func__, hw, iterfunc, arg)); 7080 7081 lhw = HW_TO_LHW(hw); 7082 7083 rcu_read_lock(); 7084 list_for_each_entry_rcu(lchanctx, &lhw->lchanctx_list, entry) { 7085 if (!lchanctx->added_to_drv) 7086 continue; 7087 iterfunc(hw, &lchanctx->chanctx_conf, arg); 7088 } 7089 rcu_read_unlock(); 7090 } 7091 7092 void 7093 linuxkpi_ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw, 7094 void (*iterfunc)(void *, struct ieee80211_sta *), void *arg) 7095 { 7096 struct lkpi_hw *lhw; 7097 struct lkpi_vif *lvif; 7098 struct lkpi_sta *lsta; 7099 struct ieee80211_sta *sta; 7100 7101 KASSERT(hw != NULL && iterfunc != NULL, 7102 ("%s: hw %p iterfunc %p arg %p\n", __func__, hw, iterfunc, arg)); 7103 7104 lhw = HW_TO_LHW(hw); 7105 7106 LKPI_80211_LHW_LVIF_LOCK(lhw); 7107 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) { 7108 7109 rcu_read_lock(); 7110 list_for_each_entry_rcu(lsta, &lvif->lsta_list, lsta_list) { 7111 if (!lsta->added_to_drv) 7112 continue; 7113 sta = LSTA_TO_STA(lsta); 7114 iterfunc(arg, sta); 7115 } 7116 rcu_read_unlock(); 7117 } 7118 LKPI_80211_LHW_LVIF_UNLOCK(lhw); 7119 } 7120 7121 struct linuxkpi_ieee80211_regdomain * 7122 lkpi_get_linuxkpi_ieee80211_regdomain(size_t n) 7123 { 7124 struct linuxkpi_ieee80211_regdomain *regd; 7125 7126 regd = kzalloc(sizeof(*regd) + n * sizeof(struct ieee80211_reg_rule), 7127 GFP_KERNEL); 7128 return (regd); 7129 } 7130 7131 int 7132 linuxkpi_regulatory_set_wiphy_regd_sync(struct wiphy *wiphy, 7133 struct linuxkpi_ieee80211_regdomain *regd) 7134 { 7135 struct lkpi_hw *lhw; 7136 struct ieee80211com *ic; 7137 struct ieee80211_regdomain *rd; 7138 7139 lhw = wiphy_priv(wiphy); 7140 ic = lhw->ic; 7141 7142 rd = &ic->ic_regdomain; 7143 if (rd->isocc[0] == '\0') { 7144 rd->isocc[0] = regd->alpha2[0]; 7145 rd->isocc[1] = regd->alpha2[1]; 7146 } 7147 7148 TODO(); 7149 /* XXX-BZ finish the rest. */ 7150 7151 return (0); 7152 } 7153 7154 void 7155 linuxkpi_ieee80211_scan_completed(struct ieee80211_hw *hw, 7156 struct cfg80211_scan_info *info) 7157 { 7158 struct lkpi_hw *lhw; 7159 struct ieee80211com *ic; 7160 struct ieee80211_scan_state *ss; 7161 7162 lhw = wiphy_priv(hw->wiphy); 7163 ic = lhw->ic; 7164 ss = ic->ic_scan; 7165 7166 TRACE_SCAN(ic, "scan_flags %b info { %ju, %6D, aborted %d }", 7167 lhw->scan_flags, LKPI_LHW_SCAN_BITS, 7168 (uintmax_t)info->scan_start_tsf, info->tsf_bssid, ":", 7169 info->aborted); 7170 7171 ieee80211_scan_done(ss->ss_vap); 7172 7173 LKPI_80211_LHW_SCAN_LOCK(lhw); 7174 free(lhw->hw_req, M_LKPI80211); 7175 lhw->hw_req = NULL; 7176 lhw->scan_flags &= ~LKPI_LHW_SCAN_RUNNING; 7177 /* The wakeup(lhw) will be called from lkpi_ic_scan_end(). */ 7178 /* wakeup(lhw); */ 7179 LKPI_80211_LHW_SCAN_UNLOCK(lhw); 7180 7181 return; 7182 } 7183 7184 static void 7185 lkpi_80211_lhw_rxq_rx_one(struct lkpi_hw *lhw, struct mbuf *m) 7186 { 7187 struct ieee80211_node *ni; 7188 #ifdef LKPI_80211_USE_MTAG 7189 struct m_tag *mtag; 7190 #endif 7191 int ok; 7192 7193 ni = NULL; 7194 #ifdef LKPI_80211_USE_MTAG 7195 mtag = m_tag_locate(m, MTAG_ABI_LKPI80211, LKPI80211_TAG_RXNI, NULL); 7196 if (mtag != NULL) { 7197 struct lkpi_80211_tag_rxni *rxni; 7198 7199 rxni = (struct lkpi_80211_tag_rxni *)(mtag + 1); 7200 ni = rxni->ni; 7201 } 7202 #else 7203 if (m->m_pkthdr.PH_loc.ptr != NULL) { 7204 ni = m->m_pkthdr.PH_loc.ptr; 7205 m->m_pkthdr.PH_loc.ptr = NULL; 7206 } 7207 #endif 7208 7209 if (ni != NULL) { 7210 ok = ieee80211_input_mimo(ni, m); 7211 ieee80211_free_node(ni); /* Release the reference. */ 7212 if (ok < 0) 7213 m_freem(m); 7214 } else { 7215 ok = ieee80211_input_mimo_all(lhw->ic, m); 7216 /* mbuf got consumed. */ 7217 } 7218 7219 #ifdef LINUXKPI_DEBUG_80211 7220 if (linuxkpi_debug_80211 & D80211_TRACE_RX) 7221 printf("TRACE-RX: %s: handled frame type %#0x\n", __func__, ok); 7222 #endif 7223 } 7224 7225 static void 7226 lkpi_80211_lhw_rxq_task(void *ctx, int pending) 7227 { 7228 struct lkpi_hw *lhw; 7229 struct mbufq mq; 7230 struct mbuf *m; 7231 7232 lhw = ctx; 7233 7234 #ifdef LINUXKPI_DEBUG_80211 7235 if (linuxkpi_debug_80211 & D80211_TRACE_RX) 7236 printf("TRACE-RX: %s: lhw %p pending %d mbuf_qlen %d\n", 7237 __func__, lhw, pending, mbufq_len(&lhw->rxq)); 7238 #endif 7239 7240 mbufq_init(&mq, IFQ_MAXLEN); 7241 7242 LKPI_80211_LHW_RXQ_LOCK(lhw); 7243 mbufq_concat(&mq, &lhw->rxq); 7244 LKPI_80211_LHW_RXQ_UNLOCK(lhw); 7245 7246 m = mbufq_dequeue(&mq); 7247 while (m != NULL) { 7248 lkpi_80211_lhw_rxq_rx_one(lhw, m); 7249 m = mbufq_dequeue(&mq); 7250 } 7251 } 7252 7253 static void 7254 lkpi_convert_rx_status(struct ieee80211_hw *hw, struct lkpi_sta *lsta, 7255 struct ieee80211_rx_status *rx_status, 7256 struct ieee80211_rx_stats *rx_stats, 7257 uint8_t *rssip) 7258 { 7259 struct ieee80211_supported_band *supband; 7260 struct rate_info rxrate; 7261 int i; 7262 uint8_t rssi; 7263 7264 memset(&rxrate, 0, sizeof(rxrate)); 7265 memset(rx_stats, 0, sizeof(*rx_stats)); 7266 rx_stats->r_flags = IEEE80211_R_NF | IEEE80211_R_RSSI; 7267 /* XXX-BZ correct hardcoded noise floor, survey data? */ 7268 rx_stats->c_nf = -96; 7269 if (ieee80211_hw_check(hw, SIGNAL_DBM) && 7270 !(rx_status->flag & RX_FLAG_NO_SIGNAL_VAL)) 7271 rssi = rx_status->signal; 7272 else 7273 rssi = rx_stats->c_nf; 7274 /* 7275 * net80211 signal strength data are in .5 dBm units relative to 7276 * the current noise floor (see comment in ieee80211_node.h). 7277 */ 7278 rssi -= rx_stats->c_nf; 7279 if (rssip != NULL) 7280 *rssip = rssi; 7281 rx_stats->c_rssi = rssi * 2; 7282 rx_stats->r_flags |= IEEE80211_R_BAND; 7283 rx_stats->c_band = 7284 lkpi_nl80211_band_to_net80211_band(rx_status->band); 7285 rx_stats->r_flags |= IEEE80211_R_FREQ | IEEE80211_R_IEEE; 7286 rx_stats->c_freq = rx_status->freq; 7287 rx_stats->c_ieee = ieee80211_mhz2ieee(rx_stats->c_freq, rx_stats->c_band); 7288 7289 rx_stats->c_rx_tsf = rx_status->mactime; 7290 7291 /* XXX RX_FLAG_MACTIME_IS_RTAP_TS64 ? */ 7292 if ((rx_status->flag & RX_FLAG_MACTIME) == 7293 (RX_FLAG_MACTIME_START|RX_FLAG_MACTIME_END)) { 7294 rx_stats->r_flags |= IEEE80211_R_TSF64; 7295 /* XXX RX_FLAG_MACTIME_PLCP_START ? */ 7296 if ((rx_status->flag & RX_FLAG_MACTIME) == RX_FLAG_MACTIME_START) 7297 rx_stats->r_flags |= IEEE80211_R_TSF_START; 7298 if ((rx_status->flag & RX_FLAG_MACTIME) == RX_FLAG_MACTIME_END) 7299 rx_stats->r_flags |= IEEE80211_R_TSF_END; 7300 /* XXX-BZ if TSF_END will net80211 do the unwind of time? */ 7301 } 7302 7303 if (rx_status->chains != 0) { 7304 int cc; 7305 int8_t crssi; 7306 7307 rx_stats->c_chain = rx_status->chains; 7308 rx_stats->r_flags |= IEEE80211_R_C_CHAIN; 7309 7310 cc = 0; 7311 for (i = 0; i < nitems(rx_status->chain_signal); i++) { 7312 if (!(rx_status->chains & BIT(i))) 7313 continue; 7314 crssi = rx_status->chain_signal[i]; 7315 crssi -= rx_stats->c_nf; 7316 rx_stats->c_rssi_ctl[i] = crssi * 2; 7317 rx_stats->c_rssi_ext[i] = crssi * 2; /* XXX _ext ??? ATH thing? */ 7318 /* We currently only have the global noise floor value. */ 7319 rx_stats->c_nf_ctl[i] = rx_stats->c_nf; 7320 rx_stats->c_nf_ext[i] = rx_stats->c_nf; 7321 cc++; 7322 } 7323 if (cc > 0) 7324 rx_stats->r_flags |= (IEEE80211_R_C_NF | IEEE80211_R_C_RSSI); 7325 } 7326 7327 /* XXX-NET80211 We are not going to populate c_phytype! */ 7328 7329 switch (rx_status->encoding) { 7330 case RX_ENC_LEGACY: 7331 { 7332 uint32_t legacy = 0; 7333 7334 supband = hw->wiphy->bands[rx_status->band]; 7335 if (supband != NULL) 7336 legacy = supband->bitrates[rx_status->rate_idx].bitrate; 7337 rx_stats->c_rate = legacy; 7338 rxrate.legacy = legacy; 7339 /* Is there a LinuxKPI way of reporting IEEE80211_RX_F_CCK / _OFDM? */ 7340 break; 7341 } 7342 case RX_ENC_HT: 7343 rx_stats->c_pktflags |= IEEE80211_RX_F_HT; 7344 rx_stats->c_rate = rx_status->rate_idx; /* mcs */ 7345 rxrate.flags |= RATE_INFO_FLAGS_MCS; 7346 rxrate.mcs = rx_status->rate_idx; 7347 if ((rx_status->enc_flags & RX_ENC_FLAG_SHORT_GI) != 0) { 7348 rx_stats->c_pktflags |= IEEE80211_RX_F_SHORTGI; 7349 rxrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 7350 } 7351 break; 7352 case RX_ENC_VHT: 7353 rx_stats->c_pktflags |= IEEE80211_RX_F_VHT; 7354 rx_stats->c_rate = rx_status->rate_idx; /* mcs */ 7355 rx_stats->c_vhtnss = rx_status->nss; 7356 rxrate.flags |= RATE_INFO_FLAGS_VHT_MCS; 7357 rxrate.mcs = rx_status->rate_idx; 7358 rxrate.nss = rx_status->nss; 7359 if ((rx_status->enc_flags & RX_ENC_FLAG_SHORT_GI) != 0) { 7360 rx_stats->c_pktflags |= IEEE80211_RX_F_SHORTGI; 7361 rxrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 7362 } 7363 break; 7364 case RX_ENC_HE: 7365 rxrate.flags |= RATE_INFO_FLAGS_HE_MCS; 7366 rxrate.mcs = rx_status->rate_idx; 7367 rxrate.nss = rx_status->nss; 7368 /* XXX TODO */ 7369 TODO("net80211 has not matching encoding for %u", rx_status->encoding); 7370 break; 7371 case RX_ENC_EHT: 7372 rxrate.flags |= RATE_INFO_FLAGS_EHT_MCS; 7373 rxrate.mcs = rx_status->rate_idx; 7374 rxrate.nss = rx_status->nss; 7375 /* XXX TODO */ 7376 TODO("net80211 has not matching encoding for %u", rx_status->encoding); 7377 break; 7378 } 7379 7380 rxrate.bw = rx_status->bw; 7381 switch (rx_status->bw) { 7382 case RATE_INFO_BW_20: 7383 rx_stats->c_width = IEEE80211_RX_FW_20MHZ; 7384 break; 7385 case RATE_INFO_BW_40: 7386 rx_stats->c_width = IEEE80211_RX_FW_40MHZ; 7387 break; 7388 case RATE_INFO_BW_80: 7389 rx_stats->c_width = IEEE80211_RX_FW_80MHZ; 7390 break; 7391 case RATE_INFO_BW_160: 7392 rx_stats->c_width = IEEE80211_RX_FW_160MHZ; 7393 break; 7394 case RATE_INFO_BW_320: 7395 case RATE_INFO_BW_HE_RU: 7396 case RATE_INFO_BW_EHT_RU: 7397 case RATE_INFO_BW_5: 7398 case RATE_INFO_BW_10: 7399 TODO("net80211 has not matching bandwidth for %u", rx_status->bw); 7400 break; 7401 } 7402 7403 if ((rx_status->enc_flags & RX_ENC_FLAG_LDPC) != 0) 7404 rx_stats->c_pktflags |= IEEE80211_RX_F_LDPC; 7405 if ((rx_status->enc_flags & RX_ENC_FLAG_STBC_MASK) != 0) 7406 rx_stats->c_pktflags |= IEEE80211_RX_F_STBC; 7407 7408 /* 7409 * We only need these for LKPI_80211_HW_CRYPTO in theory but in 7410 * case the hardware does something we do not expect always leave 7411 * these enabled. Leaving this commant as documentation for the || 1. 7412 */ 7413 #if defined(LKPI_80211_HW_CRYPTO) || 1 7414 if (rx_status->flag & RX_FLAG_DECRYPTED) { 7415 rx_stats->c_pktflags |= IEEE80211_RX_F_DECRYPTED; 7416 /* Only valid if decrypted is set. */ 7417 if (rx_status->flag & RX_FLAG_PN_VALIDATED) 7418 rx_stats->c_pktflags |= IEEE80211_RX_F_PN_VALIDATED; 7419 } 7420 if (rx_status->flag & RX_FLAG_IV_STRIPPED) 7421 rx_stats->c_pktflags |= IEEE80211_RX_F_IV_STRIP; 7422 if (rx_status->flag & RX_FLAG_ICV_STRIPPED) 7423 rx_stats->c_pktflags |= IEEE80211_RX_F_ICV_STRIP; 7424 if (rx_status->flag & RX_FLAG_MIC_STRIPPED) 7425 rx_stats->c_pktflags |= IEEE80211_RX_F_MIC_STRIP; 7426 if (rx_status->flag & RX_FLAG_MMIC_STRIPPED) 7427 rx_stats->c_pktflags |= IEEE80211_RX_F_MMIC_STRIP; 7428 if (rx_status->flag & RX_FLAG_MMIC_ERROR) 7429 rx_stats->c_pktflags |= IEEE80211_RX_F_FAIL_MMIC; 7430 if (rx_status->flag & RX_FLAG_FAILED_FCS_CRC) 7431 rx_stats->c_pktflags |= IEEE80211_RX_F_FAIL_FCSCRC; 7432 #endif 7433 7434 /* Fill in some sinfo bits to fill gaps not reported byt the driver. */ 7435 if (lsta != NULL) { 7436 memcpy(&lsta->sinfo.rxrate, &rxrate, sizeof(rxrate)); 7437 lsta->sinfo.filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE); 7438 7439 if (rx_status->chains != 0) { 7440 lsta->sinfo.chains = rx_status->chains; 7441 memcpy(lsta->sinfo.chain_signal, rx_status->chain_signal, 7442 sizeof(lsta->sinfo.chain_signal)); 7443 lsta->sinfo.filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL); 7444 } 7445 } 7446 } 7447 7448 #ifdef LINUXKPI_DEBUG_80211 7449 static void 7450 lkpi_rx_log_beacon(struct mbuf *m, struct lkpi_hw *lhw, 7451 struct ieee80211_rx_status *rx_status) 7452 { 7453 struct ieee80211_mgmt *f; 7454 uint8_t *e; 7455 char ssid[IEEE80211_NWID_LEN * 4 + 1]; 7456 7457 memset(ssid, '\0', sizeof(ssid)); 7458 7459 f = mtod(m, struct ieee80211_mgmt *); 7460 e = f->u.beacon.variable; 7461 /* 7462 * Usually SSID is right after the fixed part and for debugging we will 7463 * be fine should we miss it if it is not. 7464 */ 7465 while ((e - (uint8_t *)f) < m->m_len) { 7466 if (*e == IEEE80211_ELEMID_SSID) 7467 break; 7468 e += (2 + *(e + 1)); 7469 } 7470 if (*e == IEEE80211_ELEMID_SSID) { 7471 int i, len; 7472 char *p; 7473 7474 p = ssid; 7475 len = m->m_len - ((e + 2) - (uint8_t *)f); 7476 if (len > *(e + 1)) 7477 len = *(e + 1); 7478 e += 2; 7479 for (i = 0; i < len; i++) { 7480 /* Printable character? */ 7481 if (*e >= 0x20 && *e < 0x7f) { 7482 *p++ = *e++; 7483 } else { 7484 snprintf(p, 5, "%#04x", *e++); 7485 p += 4; 7486 } 7487 } 7488 *p = '\0'; 7489 } 7490 7491 /* We print skb, skb->data, m as we are seeing 'ghost beacons'. */ 7492 TRACE_SCAN_BEACON(lhw->ic, "Beacon: scan_flags %b, band %s freq %u chan %-4d " 7493 "len %d { %#06x %#06x %6D %6D %6D %#06x %ju %u %#06x SSID '%s' }", 7494 lhw->scan_flags, LKPI_LHW_SCAN_BITS, 7495 lkpi_nl80211_band_name(rx_status->band), rx_status->freq, 7496 linuxkpi_ieee80211_frequency_to_channel(rx_status->freq, 0), 7497 m->m_pkthdr.len, f->frame_control, f->duration_id, 7498 f->da, ":", f->sa, ":", f->bssid, ":", f->seq_ctrl, 7499 (uintmax_t)le64_to_cpu(f->u.beacon.timestamp), 7500 le16_to_cpu(f->u.beacon.beacon_int), 7501 le16_to_cpu(f->u.beacon.capab_info), ssid); 7502 } 7503 #endif 7504 7505 /* For %list see comment towards the end of the function. */ 7506 void 7507 linuxkpi_ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb, 7508 struct ieee80211_sta *sta, struct napi_struct *napi __unused, 7509 struct list_head *list __unused) 7510 { 7511 struct lkpi_hw *lhw; 7512 struct ieee80211com *ic; 7513 struct mbuf *m; 7514 struct skb_shared_info *shinfo; 7515 struct ieee80211_rx_status *rx_status; 7516 struct ieee80211_rx_stats rx_stats; 7517 struct ieee80211_node *ni; 7518 struct ieee80211vap *vap; 7519 struct ieee80211_hdr *hdr; 7520 struct lkpi_sta *lsta; 7521 int i, offset, ok, error; 7522 uint8_t rssi; 7523 bool is_beacon; 7524 7525 lhw = HW_TO_LHW(hw); 7526 ic = lhw->ic; 7527 7528 if (skb->len < 2) { 7529 /* Need 80211 stats here. */ 7530 counter_u64_add(ic->ic_ierrors, 1); 7531 IMPROVE(); 7532 goto err; 7533 } 7534 7535 /* 7536 * For now do the data copy; we can later improve things. Might even 7537 * have an mbuf backing the skb data then? 7538 */ 7539 m = m_get3(skb->len, M_NOWAIT, MT_DATA, M_PKTHDR); 7540 if (m == NULL) { 7541 counter_u64_add(ic->ic_ierrors, 1); 7542 goto err; 7543 } 7544 m_copyback(m, 0, skb->tail - skb->data, skb->data); 7545 7546 shinfo = skb_shinfo(skb); 7547 offset = m->m_len; 7548 for (i = 0; i < shinfo->nr_frags; i++) { 7549 m_copyback(m, offset, shinfo->frags[i].size, 7550 (uint8_t *)linux_page_address(shinfo->frags[i].page) + 7551 shinfo->frags[i].offset); 7552 offset += shinfo->frags[i].size; 7553 } 7554 7555 rx_status = IEEE80211_SKB_RXCB(skb); 7556 7557 hdr = (void *)skb->data; 7558 is_beacon = ieee80211_is_beacon(hdr->frame_control); 7559 7560 #ifdef LINUXKPI_DEBUG_80211 7561 /* 7562 * We use the mbuf here as otherwise the variable part might 7563 * be in skb frags. 7564 */ 7565 if (is_beacon && ((linuxkpi_debug_80211 & D80211_SCAN_BEACON) != 0)) 7566 lkpi_rx_log_beacon(m, lhw, rx_status); 7567 7568 if (is_beacon && (linuxkpi_debug_80211 & D80211_TRACE_RX_BEACONS) == 0 && 7569 (linuxkpi_debug_80211 & D80211_SCAN_BEACON) == 0) 7570 goto no_trace_beacons; 7571 7572 if (linuxkpi_debug_80211 & D80211_TRACE_RX) 7573 printf("TRACE-RX: %s: skb %p l/d/t-len (%u/%u/%u) " 7574 "h %p d %p t %p e %p sh %p (%u) m %p plen %u len %u%s\n", 7575 __func__, skb, skb->len, skb->data_len, 7576 skb->truesize, skb->head, skb->data, skb->tail, skb->end, 7577 shinfo, shinfo->nr_frags, 7578 m, m->m_pkthdr.len, m->m_len, is_beacon ? " beacon" : ""); 7579 7580 if (linuxkpi_debug_80211 & D80211_TRACE_RX_DUMP) 7581 hexdump(mtod(m, const void *), m->m_len, "RX (raw) ", 0); 7582 7583 /* Implement a dump_rxcb() !!! */ 7584 if ((linuxkpi_debug_80211 & D80211_TRACE_RX) != 0 || 7585 (linuxkpi_debug_80211 & D80211_SCAN_BEACON) != 0) 7586 printf("TRACE-RX: %s: RXCB: %ju %ju %u, %b, %u, %#0x, %#0x, " 7587 "%u band %u, %u { %d %d %d %d }, %d, %#x %#x %#x %#x %u %u %u\n", 7588 __func__, 7589 (uintmax_t)rx_status->boottime_ns, 7590 (uintmax_t)rx_status->mactime, 7591 rx_status->device_timestamp, 7592 rx_status->flag, IEEE80211_RX_STATUS_FLAGS_BITS, 7593 rx_status->freq, 7594 rx_status->bw, 7595 rx_status->encoding, 7596 rx_status->ampdu_reference, 7597 rx_status->band, 7598 rx_status->chains, 7599 rx_status->chain_signal[0], 7600 rx_status->chain_signal[1], 7601 rx_status->chain_signal[2], 7602 rx_status->chain_signal[3], 7603 rx_status->signal, 7604 rx_status->enc_flags, 7605 rx_status->he_dcm, 7606 rx_status->he_gi, 7607 rx_status->he_ru, 7608 rx_status->zero_length_psdu_type, 7609 rx_status->nss, 7610 rx_status->rate_idx); 7611 no_trace_beacons: 7612 #endif 7613 7614 lsta = NULL; 7615 if (sta != NULL) { 7616 lsta = STA_TO_LSTA(sta); 7617 ni = ieee80211_ref_node(lsta->ni); 7618 } else { 7619 struct ieee80211_frame_min *wh; 7620 7621 wh = mtod(m, struct ieee80211_frame_min *); 7622 ni = ieee80211_find_rxnode(ic, wh); 7623 if (ni != NULL) 7624 lsta = ni->ni_drv_data; 7625 } 7626 7627 rssi = 0; 7628 lkpi_convert_rx_status(hw, lsta, rx_status, &rx_stats, &rssi); 7629 7630 ok = ieee80211_add_rx_params(m, &rx_stats); 7631 if (ok == 0) { 7632 m_freem(m); 7633 counter_u64_add(ic->ic_ierrors, 1); 7634 goto err; 7635 } 7636 7637 if (ni != NULL) 7638 vap = ni->ni_vap; 7639 else 7640 /* 7641 * XXX-BZ can we improve this by looking at the frame hdr 7642 * or other meta-data passed up? 7643 */ 7644 vap = TAILQ_FIRST(&ic->ic_vaps); 7645 7646 #ifdef LINUXKPI_DEBUG_80211 7647 if (linuxkpi_debug_80211 & D80211_TRACE_RX) 7648 printf("TRACE-RX: %s: sta %p lsta %p state %d ni %p vap %p%s\n", 7649 __func__, sta, lsta, (lsta != NULL) ? lsta->state : -1, 7650 ni, vap, is_beacon ? " beacon" : ""); 7651 #endif 7652 7653 if (ni != NULL && vap != NULL && is_beacon && 7654 rx_status->device_timestamp > 0 && 7655 m->m_pkthdr.len >= sizeof(struct ieee80211_frame)) { 7656 struct lkpi_vif *lvif; 7657 struct ieee80211_vif *vif; 7658 struct ieee80211_frame *wh; 7659 7660 wh = mtod(m, struct ieee80211_frame *); 7661 if (!IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_bssid)) 7662 goto skip_device_ts; 7663 7664 lvif = VAP_TO_LVIF(vap); 7665 vif = LVIF_TO_VIF(lvif); 7666 7667 IMPROVE("TIMING_BEACON_ONLY?"); 7668 /* mac80211 specific (not net80211) so keep it here. */ 7669 vif->bss_conf.sync_device_ts = rx_status->device_timestamp; 7670 /* 7671 * net80211 should take care of the other information (sync_tsf, 7672 * sync_dtim_count) as otherwise we need to parse the beacon. 7673 */ 7674 skip_device_ts: 7675 ; 7676 } 7677 7678 if (vap != NULL && vap->iv_state > IEEE80211_S_INIT && 7679 ieee80211_radiotap_active_vap(vap)) { 7680 struct lkpi_radiotap_rx_hdr *rtap; 7681 7682 rtap = &lhw->rtap_rx; 7683 rtap->wr_tsft = rx_status->device_timestamp; 7684 rtap->wr_flags = 0; 7685 if (rx_status->enc_flags & RX_ENC_FLAG_SHORTPRE) 7686 rtap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 7687 if (rx_status->enc_flags & RX_ENC_FLAG_SHORT_GI) 7688 rtap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTGI; 7689 #if 0 /* .. or it does not given we strip it below. */ 7690 if (ieee80211_hw_check(hw, RX_INCLUDES_FCS)) 7691 rtap->wr_flags |= IEEE80211_RADIOTAP_F_FCS; 7692 #endif 7693 if (rx_status->flag & RX_FLAG_FAILED_FCS_CRC) 7694 rtap->wr_flags |= IEEE80211_RADIOTAP_F_BADFCS; 7695 rtap->wr_rate = 0; 7696 IMPROVE(); 7697 /* XXX TODO status->encoding / rate_index / bw */ 7698 rtap->wr_chan_freq = htole16(rx_stats.c_freq); 7699 if (ic->ic_curchan->ic_ieee == rx_stats.c_ieee) 7700 rtap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags); 7701 rtap->wr_dbm_antsignal = rssi; 7702 rtap->wr_dbm_antnoise = rx_stats.c_nf; 7703 } 7704 7705 if (ieee80211_hw_check(hw, RX_INCLUDES_FCS)) 7706 m_adj(m, -IEEE80211_CRC_LEN); 7707 7708 #if 0 7709 if (list != NULL) { 7710 /* 7711 * Normally this would be queued up and delivered by 7712 * netif_receive_skb_list(), napi_gro_receive(), or the like. 7713 * See mt76::mac80211.c as only current possible consumer. 7714 */ 7715 IMPROVE("we simply pass the packet to net80211 to deal with."); 7716 } 7717 #endif 7718 7719 /* Attach meta-information to the mbuf for the deferred RX path. */ 7720 if (ni != NULL) { 7721 #ifdef LKPI_80211_USE_MTAG 7722 struct m_tag *mtag; 7723 struct lkpi_80211_tag_rxni *rxni; 7724 7725 mtag = m_tag_alloc(MTAG_ABI_LKPI80211, LKPI80211_TAG_RXNI, 7726 sizeof(*rxni), IEEE80211_M_NOWAIT); 7727 if (mtag == NULL) { 7728 m_freem(m); 7729 counter_u64_add(ic->ic_ierrors, 1); 7730 goto err; 7731 } 7732 rxni = (struct lkpi_80211_tag_rxni *)(mtag + 1); 7733 rxni->ni = ni; /* We hold a reference. */ 7734 m_tag_prepend(m, mtag); 7735 #else 7736 m->m_pkthdr.PH_loc.ptr = ni; /* We hold a reference. */ 7737 #endif 7738 } 7739 7740 LKPI_80211_LHW_RXQ_LOCK(lhw); 7741 if (lhw->rxq_stopped) { 7742 LKPI_80211_LHW_RXQ_UNLOCK(lhw); 7743 m_freem(m); 7744 counter_u64_add(ic->ic_ierrors, 1); 7745 goto err; 7746 } 7747 7748 error = mbufq_enqueue(&lhw->rxq, m); 7749 if (error != 0) { 7750 LKPI_80211_LHW_RXQ_UNLOCK(lhw); 7751 m_freem(m); 7752 counter_u64_add(ic->ic_ierrors, 1); 7753 #ifdef LINUXKPI_DEBUG_80211 7754 if (linuxkpi_debug_80211 & D80211_TRACE_RX) 7755 ic_printf(ni->ni_ic, "%s: mbufq_enqueue failed: %d\n", 7756 __func__, error); 7757 #endif 7758 goto err; 7759 } 7760 taskqueue_enqueue(taskqueue_thread, &lhw->rxq_task); 7761 LKPI_80211_LHW_RXQ_UNLOCK(lhw); 7762 7763 IMPROVE(); 7764 7765 err: 7766 /* The skb is ours so we can free it :-) */ 7767 kfree_skb(skb); 7768 } 7769 7770 uint8_t 7771 linuxkpi_ieee80211_get_tid(struct ieee80211_hdr *hdr, bool nonqos_ok) 7772 { 7773 const struct ieee80211_frame *wh; 7774 uint8_t tid; 7775 7776 /* Linux seems to assume this is a QOS-Data-Frame */ 7777 KASSERT(nonqos_ok || ieee80211_is_data_qos(hdr->frame_control), 7778 ("%s: hdr %p fc %#06x not qos_data\n", __func__, hdr, 7779 hdr->frame_control)); 7780 7781 wh = (const struct ieee80211_frame *)hdr; 7782 tid = ieee80211_gettid(wh); 7783 KASSERT(nonqos_ok || tid == (tid & IEEE80211_QOS_TID), ("%s: tid %u " 7784 "not expected (%u?)\n", __func__, tid, IEEE80211_NONQOS_TID)); 7785 7786 return (tid); 7787 } 7788 7789 /* -------------------------------------------------------------------------- */ 7790 7791 static void 7792 lkpi_wiphy_work(struct work_struct *work) 7793 { 7794 struct lkpi_wiphy *lwiphy; 7795 struct wiphy *wiphy; 7796 struct wiphy_work *wk; 7797 7798 lwiphy = container_of(work, struct lkpi_wiphy, wwk); 7799 wiphy = LWIPHY_TO_WIPHY(lwiphy); 7800 7801 wiphy_lock(wiphy); 7802 7803 LKPI_80211_LWIPHY_WORK_LOCK(lwiphy); 7804 wk = list_first_entry_or_null(&lwiphy->wwk_list, struct wiphy_work, entry); 7805 /* If there is nothing we do nothing. */ 7806 if (wk == NULL) { 7807 LKPI_80211_LWIPHY_WORK_UNLOCK(lwiphy); 7808 wiphy_unlock(wiphy); 7809 return; 7810 } 7811 list_del_init(&wk->entry); 7812 7813 /* More work to do? */ 7814 if (!list_empty(&lwiphy->wwk_list)) 7815 schedule_work(work); 7816 LKPI_80211_LWIPHY_WORK_UNLOCK(lwiphy); 7817 7818 /* Finally call the (*wiphy_work_fn)() function. */ 7819 wk->fn(wiphy, wk); 7820 7821 wiphy_unlock(wiphy); 7822 } 7823 7824 void 7825 linuxkpi_wiphy_work_queue(struct wiphy *wiphy, struct wiphy_work *wwk) 7826 { 7827 struct lkpi_wiphy *lwiphy; 7828 7829 lwiphy = WIPHY_TO_LWIPHY(wiphy); 7830 7831 LKPI_80211_LWIPHY_WORK_LOCK(lwiphy); 7832 /* Do not double-queue. */ 7833 if (list_empty(&wwk->entry)) 7834 list_add_tail(&wwk->entry, &lwiphy->wwk_list); 7835 LKPI_80211_LWIPHY_WORK_UNLOCK(lwiphy); 7836 7837 /* 7838 * See how ieee80211_queue_work() work continues in Linux or if things 7839 * migrate here over time? 7840 * Use a system queue from linux/workqueue.h for now. 7841 */ 7842 queue_work(system_wq, &lwiphy->wwk); 7843 } 7844 7845 void 7846 linuxkpi_wiphy_work_cancel(struct wiphy *wiphy, struct wiphy_work *wwk) 7847 { 7848 struct lkpi_wiphy *lwiphy; 7849 7850 lwiphy = WIPHY_TO_LWIPHY(wiphy); 7851 7852 LKPI_80211_LWIPHY_WORK_LOCK(lwiphy); 7853 /* Only cancel if queued. */ 7854 if (!list_empty(&wwk->entry)) 7855 list_del_init(&wwk->entry); 7856 LKPI_80211_LWIPHY_WORK_UNLOCK(lwiphy); 7857 } 7858 7859 void 7860 linuxkpi_wiphy_work_flush(struct wiphy *wiphy, struct wiphy_work *wwk) 7861 { 7862 struct lkpi_wiphy *lwiphy; 7863 struct wiphy_work *wk; 7864 7865 lwiphy = WIPHY_TO_LWIPHY(wiphy); 7866 LKPI_80211_LWIPHY_WORK_LOCK(lwiphy); 7867 /* If wwk is unset, flush everything; called when wiphy is shut down. */ 7868 if (wwk != NULL && list_empty(&wwk->entry)) { 7869 LKPI_80211_LWIPHY_WORK_UNLOCK(lwiphy); 7870 return; 7871 } 7872 7873 while (!list_empty(&lwiphy->wwk_list)) { 7874 7875 wk = list_first_entry(&lwiphy->wwk_list, struct wiphy_work, 7876 entry); 7877 list_del_init(&wk->entry); 7878 LKPI_80211_LWIPHY_WORK_UNLOCK(lwiphy); 7879 wk->fn(wiphy, wk); 7880 LKPI_80211_LWIPHY_WORK_LOCK(lwiphy); 7881 if (wk == wwk) 7882 break; 7883 } 7884 LKPI_80211_LWIPHY_WORK_UNLOCK(lwiphy); 7885 } 7886 7887 void 7888 lkpi_wiphy_delayed_work_timer(struct timer_list *tl) 7889 { 7890 struct wiphy_delayed_work *wdwk; 7891 7892 wdwk = timer_container_of(wdwk, tl, timer); 7893 wiphy_work_queue(wdwk->wiphy, &wdwk->work); 7894 } 7895 7896 void 7897 linuxkpi_wiphy_delayed_work_queue(struct wiphy *wiphy, 7898 struct wiphy_delayed_work *wdwk, unsigned long delay) 7899 { 7900 if (delay == 0) { 7901 /* Run right away. */ 7902 del_timer(&wdwk->timer); 7903 wiphy_work_queue(wiphy, &wdwk->work); 7904 } else { 7905 wdwk->wiphy = wiphy; 7906 mod_timer(&wdwk->timer, jiffies + delay); 7907 } 7908 } 7909 7910 void 7911 linuxkpi_wiphy_delayed_work_cancel(struct wiphy *wiphy, 7912 struct wiphy_delayed_work *wdwk) 7913 { 7914 del_timer_sync(&wdwk->timer); 7915 wiphy_work_cancel(wiphy, &wdwk->work); 7916 } 7917 7918 void 7919 linuxkpi_wiphy_delayed_work_flush(struct wiphy *wiphy, 7920 struct wiphy_delayed_work *wdwk) 7921 { 7922 lockdep_assert_held(&wiphy->mtx); 7923 7924 del_timer_sync(&wdwk->timer); 7925 wiphy_work_flush(wiphy, &wdwk->work); 7926 } 7927 7928 /* -------------------------------------------------------------------------- */ 7929 7930 struct wiphy * 7931 linuxkpi_wiphy_new(const struct cfg80211_ops *ops, size_t priv_len) 7932 { 7933 struct lkpi_wiphy *lwiphy; 7934 struct wiphy *wiphy; 7935 7936 lwiphy = kzalloc(sizeof(*lwiphy) + priv_len, GFP_KERNEL); 7937 if (lwiphy == NULL) 7938 return (NULL); 7939 lwiphy->ops = ops; 7940 7941 LKPI_80211_LWIPHY_WORK_LOCK_INIT(lwiphy); 7942 INIT_LIST_HEAD(&lwiphy->wwk_list); 7943 INIT_WORK(&lwiphy->wwk, lkpi_wiphy_work); 7944 7945 wiphy = LWIPHY_TO_WIPHY(lwiphy); 7946 7947 mutex_init(&wiphy->mtx); 7948 TODO(); 7949 7950 return (wiphy); 7951 } 7952 7953 void 7954 linuxkpi_wiphy_free(struct wiphy *wiphy) 7955 { 7956 struct lkpi_wiphy *lwiphy; 7957 7958 if (wiphy == NULL) 7959 return; 7960 7961 linuxkpi_wiphy_work_flush(wiphy, NULL); 7962 mutex_destroy(&wiphy->mtx); 7963 7964 lwiphy = WIPHY_TO_LWIPHY(wiphy); 7965 LKPI_80211_LWIPHY_WORK_LOCK_DESTROY(lwiphy); 7966 7967 kfree(lwiphy); 7968 } 7969 7970 static uint32_t 7971 lkpi_cfg80211_calculate_bitrate_ht(struct rate_info *rate) 7972 { 7973 TODO("cfg80211_calculate_bitrate_ht"); 7974 return (rate->legacy); 7975 } 7976 7977 static uint32_t 7978 lkpi_cfg80211_calculate_bitrate_vht(struct rate_info *rate) 7979 { 7980 TODO("cfg80211_calculate_bitrate_vht"); 7981 return (rate->legacy); 7982 } 7983 7984 uint32_t 7985 linuxkpi_cfg80211_calculate_bitrate(struct rate_info *rate) 7986 { 7987 7988 /* Beware: order! */ 7989 if (rate->flags & RATE_INFO_FLAGS_MCS) 7990 return (lkpi_cfg80211_calculate_bitrate_ht(rate)); 7991 7992 if (rate->flags & RATE_INFO_FLAGS_VHT_MCS) 7993 return (lkpi_cfg80211_calculate_bitrate_vht(rate)); 7994 7995 IMPROVE("HE/EHT/..."); 7996 7997 return (rate->legacy); 7998 } 7999 8000 uint32_t 8001 linuxkpi_ieee80211_channel_to_frequency(uint32_t channel, 8002 enum nl80211_band band) 8003 { 8004 8005 switch (band) { 8006 case NL80211_BAND_2GHZ: 8007 return (ieee80211_ieee2mhz(channel, IEEE80211_CHAN_2GHZ)); 8008 break; 8009 case NL80211_BAND_5GHZ: 8010 return (ieee80211_ieee2mhz(channel, IEEE80211_CHAN_5GHZ)); 8011 break; 8012 default: 8013 /* XXX abort, retry, error, panic? */ 8014 break; 8015 } 8016 8017 return (0); 8018 } 8019 8020 uint32_t 8021 linuxkpi_ieee80211_frequency_to_channel(uint32_t freq, uint32_t flags __unused) 8022 { 8023 8024 return (ieee80211_mhz2ieee(freq, 0)); 8025 } 8026 8027 #if 0 8028 static struct lkpi_sta * 8029 lkpi_find_lsta_by_ni(struct lkpi_vif *lvif, struct ieee80211_node *ni) 8030 { 8031 struct lkpi_sta *lsta, *temp; 8032 8033 rcu_read_lock(); 8034 list_for_each_entry_rcu(lsta, &lvif->lsta_list, lsta_list) { 8035 if (lsta->ni == ni) { 8036 rcu_read_unlock(); 8037 return (lsta); 8038 } 8039 } 8040 rcu_read_unlock(); 8041 8042 return (NULL); 8043 } 8044 #endif 8045 8046 struct ieee80211_sta * 8047 linuxkpi_ieee80211_find_sta(struct ieee80211_vif *vif, const u8 *peer) 8048 { 8049 struct lkpi_vif *lvif; 8050 struct lkpi_sta *lsta; 8051 struct ieee80211_sta *sta; 8052 8053 lvif = VIF_TO_LVIF(vif); 8054 8055 rcu_read_lock(); 8056 list_for_each_entry_rcu(lsta, &lvif->lsta_list, lsta_list) { 8057 sta = LSTA_TO_STA(lsta); 8058 if (IEEE80211_ADDR_EQ(sta->addr, peer)) { 8059 rcu_read_unlock(); 8060 return (sta); 8061 } 8062 } 8063 rcu_read_unlock(); 8064 return (NULL); 8065 } 8066 8067 struct ieee80211_sta * 8068 linuxkpi_ieee80211_find_sta_by_ifaddr(struct ieee80211_hw *hw, 8069 const uint8_t *addr, const uint8_t *ourvifaddr) 8070 { 8071 struct lkpi_hw *lhw; 8072 struct lkpi_vif *lvif; 8073 struct lkpi_sta *lsta; 8074 struct ieee80211_vif *vif; 8075 struct ieee80211_sta *sta; 8076 8077 lhw = wiphy_priv(hw->wiphy); 8078 sta = NULL; 8079 8080 LKPI_80211_LHW_LVIF_LOCK(lhw); 8081 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) { 8082 8083 /* XXX-BZ check our address from the vif. */ 8084 8085 vif = LVIF_TO_VIF(lvif); 8086 if (ourvifaddr != NULL && 8087 !IEEE80211_ADDR_EQ(vif->addr, ourvifaddr)) 8088 continue; 8089 sta = linuxkpi_ieee80211_find_sta(vif, addr); 8090 if (sta != NULL) 8091 break; 8092 } 8093 LKPI_80211_LHW_LVIF_UNLOCK(lhw); 8094 8095 if (sta != NULL) { 8096 lsta = STA_TO_LSTA(sta); 8097 if (!lsta->added_to_drv) 8098 return (NULL); 8099 } 8100 8101 return (sta); 8102 } 8103 8104 struct sk_buff * 8105 linuxkpi_ieee80211_tx_dequeue(struct ieee80211_hw *hw, 8106 struct ieee80211_txq *txq) 8107 { 8108 struct lkpi_txq *ltxq; 8109 struct lkpi_vif *lvif; 8110 struct sk_buff *skb; 8111 8112 IMPROVE("wiphy_lock? or assert?"); 8113 skb = NULL; 8114 ltxq = TXQ_TO_LTXQ(txq); 8115 ltxq->seen_dequeue = true; 8116 8117 if (ltxq->stopped) 8118 goto stopped; 8119 8120 lvif = VIF_TO_LVIF(ltxq->txq.vif); 8121 if (lvif->hw_queue_stopped[ltxq->txq.ac]) { 8122 ltxq->stopped = true; 8123 goto stopped; 8124 } 8125 8126 IMPROVE("hw(TX_FRAG_LIST)"); 8127 8128 LKPI_80211_LTXQ_LOCK(ltxq); 8129 skb = skb_dequeue(<xq->skbq); 8130 LKPI_80211_LTXQ_UNLOCK(ltxq); 8131 8132 stopped: 8133 return (skb); 8134 } 8135 8136 void 8137 linuxkpi_ieee80211_txq_get_depth(struct ieee80211_txq *txq, 8138 unsigned long *frame_cnt, unsigned long *byte_cnt) 8139 { 8140 struct lkpi_txq *ltxq; 8141 struct sk_buff *skb; 8142 unsigned long fc, bc; 8143 8144 ltxq = TXQ_TO_LTXQ(txq); 8145 8146 fc = bc = 0; 8147 LKPI_80211_LTXQ_LOCK(ltxq); 8148 skb_queue_walk(<xq->skbq, skb) { 8149 fc++; 8150 bc += skb->len; 8151 } 8152 LKPI_80211_LTXQ_UNLOCK(ltxq); 8153 if (frame_cnt) 8154 *frame_cnt = fc; 8155 if (byte_cnt) 8156 *byte_cnt = bc; 8157 8158 /* Validate that this is doing the correct thing. */ 8159 /* Should we keep track on en/dequeue? */ 8160 IMPROVE(); 8161 } 8162 8163 /* 8164 * We are called from ieee80211_free_txskb() or ieee80211_tx_status(). 8165 * The latter tries to derive the success status from the info flags 8166 * passed back from the driver. rawx_mit() saves the ni on the m and the 8167 * m on the skb for us to be able to give feedback to net80211. 8168 */ 8169 static void 8170 _lkpi_ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb, 8171 int status) 8172 { 8173 struct ieee80211_node *ni; 8174 struct mbuf *m; 8175 8176 m = skb->m; 8177 skb->m = NULL; 8178 8179 if (m != NULL) { 8180 ni = m->m_pkthdr.PH_loc.ptr; 8181 /* Status: 0 is ok, != 0 is error. */ 8182 ieee80211_tx_complete(ni, m, status); 8183 /* ni & mbuf were consumed. */ 8184 } 8185 } 8186 8187 void 8188 linuxkpi_ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb, 8189 int status) 8190 { 8191 8192 _lkpi_ieee80211_free_txskb(hw, skb, status); 8193 kfree_skb(skb); 8194 } 8195 8196 void 8197 linuxkpi_ieee80211_tx_status_ext(struct ieee80211_hw *hw, 8198 struct ieee80211_tx_status *txstat) 8199 { 8200 struct sk_buff *skb; 8201 struct ieee80211_tx_info *info; 8202 struct ieee80211_ratectl_tx_status txs; 8203 struct ieee80211_node *ni; 8204 int status; 8205 8206 skb = txstat->skb; 8207 if (skb->m != NULL) { 8208 struct mbuf *m; 8209 8210 m = skb->m; 8211 ni = m->m_pkthdr.PH_loc.ptr; 8212 memset(&txs, 0, sizeof(txs)); 8213 } else { 8214 ni = NULL; 8215 } 8216 8217 info = txstat->info; 8218 if (info->flags & IEEE80211_TX_STAT_ACK) { 8219 status = 0; /* No error. */ 8220 txs.status = IEEE80211_RATECTL_TX_SUCCESS; 8221 } else { 8222 status = 1; 8223 txs.status = IEEE80211_RATECTL_TX_FAIL_UNSPECIFIED; 8224 } 8225 8226 if (ni != NULL) { 8227 txs.pktlen = skb->len; 8228 txs.flags |= IEEE80211_RATECTL_STATUS_PKTLEN; 8229 if (info->status.rates[0].count > 1) { 8230 txs.long_retries = info->status.rates[0].count - 1; /* 1 + retries in drivers. */ 8231 txs.flags |= IEEE80211_RATECTL_STATUS_LONG_RETRY; 8232 } 8233 #if 0 /* Unused in net80211 currently. */ 8234 /* XXX-BZ convert check .flags for MCS/VHT/.. */ 8235 txs.final_rate = info->status.rates[0].idx; 8236 txs.flags |= IEEE80211_RATECTL_STATUS_FINAL_RATE; 8237 #endif 8238 if (info->status.flags & IEEE80211_TX_STATUS_ACK_SIGNAL_VALID) { 8239 txs.rssi = info->status.ack_signal; /* XXX-BZ CONVERT? */ 8240 txs.flags |= IEEE80211_RATECTL_STATUS_RSSI; 8241 } 8242 8243 IMPROVE("only update rate if needed but that requires us to get a proper rate from mo_sta_statistics"); 8244 ieee80211_ratectl_tx_complete(ni, &txs); 8245 ieee80211_ratectl_rate(ni->ni_vap->iv_bss, NULL, 0); 8246 8247 #ifdef LINUXKPI_DEBUG_80211 8248 if (linuxkpi_debug_80211 & D80211_TRACE_TX) { 8249 printf("TX-RATE: %s: long_retries %d\n", __func__, 8250 txs.long_retries); 8251 } 8252 #endif 8253 } 8254 8255 #ifdef LINUXKPI_DEBUG_80211 8256 if (linuxkpi_debug_80211 & D80211_TRACE_TX) 8257 printf("TX-STATUS: %s: hw %p skb %p status %d : flags %#x " 8258 "band %u hw_queue %u tx_time_est %d : " 8259 "rates [ %u %u %#x, %u %u %#x, %u %u %#x, %u %u %#x ] " 8260 "ack_signal %u ampdu_ack_len %u ampdu_len %u antenna %u " 8261 "tx_time %u flags %#x " 8262 "status_driver_data [ %p %p ]\n", 8263 __func__, hw, skb, status, info->flags, 8264 info->band, info->hw_queue, info->tx_time_est, 8265 info->status.rates[0].idx, info->status.rates[0].count, 8266 info->status.rates[0].flags, 8267 info->status.rates[1].idx, info->status.rates[1].count, 8268 info->status.rates[1].flags, 8269 info->status.rates[2].idx, info->status.rates[2].count, 8270 info->status.rates[2].flags, 8271 info->status.rates[3].idx, info->status.rates[3].count, 8272 info->status.rates[3].flags, 8273 info->status.ack_signal, info->status.ampdu_ack_len, 8274 info->status.ampdu_len, info->status.antenna, 8275 info->status.tx_time, info->status.flags, 8276 info->status.status_driver_data[0], 8277 info->status.status_driver_data[1]); 8278 #endif 8279 8280 if (txstat->free_list) { 8281 _lkpi_ieee80211_free_txskb(hw, skb, status); 8282 list_add_tail(&skb->list, txstat->free_list); 8283 } else { 8284 linuxkpi_ieee80211_free_txskb(hw, skb, status); 8285 } 8286 } 8287 8288 void 8289 linuxkpi_ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb) 8290 { 8291 struct ieee80211_tx_status status; 8292 8293 memset(&status, 0, sizeof(status)); 8294 status.info = IEEE80211_SKB_CB(skb); 8295 status.skb = skb; 8296 /* sta, n_rates, rates, free_list? */ 8297 8298 ieee80211_tx_status_ext(hw, &status); 8299 } 8300 8301 /* 8302 * This is an internal bandaid for the moment for the way we glue 8303 * skbs and mbufs together for TX. Once we have skbs backed by 8304 * mbufs this should go away. 8305 * This is a public function but kept on the private KPI (lkpi_) 8306 * and is not exposed by a header file. 8307 */ 8308 static void 8309 lkpi_ieee80211_free_skb_mbuf(void *p) 8310 { 8311 struct ieee80211_node *ni; 8312 struct mbuf *m; 8313 8314 if (p == NULL) 8315 return; 8316 8317 m = (struct mbuf *)p; 8318 M_ASSERTPKTHDR(m); 8319 8320 ni = m->m_pkthdr.PH_loc.ptr; 8321 m->m_pkthdr.PH_loc.ptr = NULL; 8322 if (ni != NULL) 8323 ieee80211_free_node(ni); 8324 m_freem(m); 8325 } 8326 8327 void 8328 linuxkpi_ieee80211_queue_delayed_work(struct ieee80211_hw *hw, 8329 struct delayed_work *w, int delay) 8330 { 8331 struct lkpi_hw *lhw; 8332 8333 /* Need to make sure hw is in a stable (non-suspended) state. */ 8334 IMPROVE(); 8335 8336 lhw = HW_TO_LHW(hw); 8337 queue_delayed_work(lhw->workq, w, delay); 8338 } 8339 8340 void 8341 linuxkpi_ieee80211_queue_work(struct ieee80211_hw *hw, 8342 struct work_struct *w) 8343 { 8344 struct lkpi_hw *lhw; 8345 8346 /* Need to make sure hw is in a stable (non-suspended) state. */ 8347 IMPROVE(); 8348 8349 lhw = HW_TO_LHW(hw); 8350 queue_work(lhw->workq, w); 8351 } 8352 8353 struct sk_buff * 8354 linuxkpi_ieee80211_probereq_get(struct ieee80211_hw *hw, const uint8_t *addr, 8355 const uint8_t *ssid, size_t ssid_len, size_t tailroom) 8356 { 8357 struct sk_buff *skb; 8358 struct ieee80211_frame *wh; 8359 uint8_t *p; 8360 size_t len; 8361 8362 len = sizeof(*wh); 8363 len += 2 + ssid_len; 8364 8365 skb = dev_alloc_skb(hw->extra_tx_headroom + len + tailroom); 8366 if (skb == NULL) 8367 return (NULL); 8368 8369 skb_reserve(skb, hw->extra_tx_headroom); 8370 8371 wh = skb_put_zero(skb, sizeof(*wh)); 8372 wh->i_fc[0] = IEEE80211_FC0_VERSION_0; 8373 wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_PROBE_REQ | IEEE80211_FC0_TYPE_MGT; 8374 IEEE80211_ADDR_COPY(wh->i_addr1, ieee80211broadcastaddr); 8375 IEEE80211_ADDR_COPY(wh->i_addr2, addr); 8376 IEEE80211_ADDR_COPY(wh->i_addr3, ieee80211broadcastaddr); 8377 8378 p = skb_put(skb, 2 + ssid_len); 8379 *p++ = IEEE80211_ELEMID_SSID; 8380 *p++ = ssid_len; 8381 if (ssid_len > 0) 8382 memcpy(p, ssid, ssid_len); 8383 8384 return (skb); 8385 } 8386 8387 struct sk_buff * 8388 linuxkpi_ieee80211_pspoll_get(struct ieee80211_hw *hw, 8389 struct ieee80211_vif *vif) 8390 { 8391 struct lkpi_vif *lvif; 8392 struct ieee80211vap *vap; 8393 struct sk_buff *skb; 8394 struct ieee80211_frame_pspoll *psp; 8395 uint16_t v; 8396 8397 skb = dev_alloc_skb(hw->extra_tx_headroom + sizeof(*psp)); 8398 if (skb == NULL) 8399 return (NULL); 8400 8401 skb_reserve(skb, hw->extra_tx_headroom); 8402 8403 lvif = VIF_TO_LVIF(vif); 8404 vap = LVIF_TO_VAP(lvif); 8405 8406 psp = skb_put_zero(skb, sizeof(*psp)); 8407 psp->i_fc[0] = IEEE80211_FC0_VERSION_0; 8408 psp->i_fc[0] |= IEEE80211_FC0_SUBTYPE_PS_POLL | IEEE80211_FC0_TYPE_CTL; 8409 v = htole16(vif->cfg.aid | 1<<15 | 1<<16); 8410 memcpy(&psp->i_aid, &v, sizeof(v)); 8411 IEEE80211_ADDR_COPY(psp->i_bssid, vap->iv_bss->ni_macaddr); 8412 IEEE80211_ADDR_COPY(psp->i_ta, vif->addr); 8413 8414 return (skb); 8415 } 8416 8417 struct sk_buff * 8418 linuxkpi_ieee80211_nullfunc_get(struct ieee80211_hw *hw, 8419 struct ieee80211_vif *vif, int linkid, bool qos) 8420 { 8421 struct lkpi_vif *lvif; 8422 struct ieee80211vap *vap; 8423 struct sk_buff *skb; 8424 struct ieee80211_frame *nullf; 8425 8426 IMPROVE("linkid"); 8427 8428 skb = dev_alloc_skb(hw->extra_tx_headroom + sizeof(*nullf)); 8429 if (skb == NULL) 8430 return (NULL); 8431 8432 skb_reserve(skb, hw->extra_tx_headroom); 8433 8434 lvif = VIF_TO_LVIF(vif); 8435 vap = LVIF_TO_VAP(lvif); 8436 8437 nullf = skb_put_zero(skb, sizeof(*nullf)); 8438 nullf->i_fc[0] = IEEE80211_FC0_VERSION_0; 8439 nullf->i_fc[0] |= IEEE80211_FC0_SUBTYPE_NODATA | IEEE80211_FC0_TYPE_DATA; 8440 nullf->i_fc[1] = IEEE80211_FC1_DIR_TODS; 8441 8442 IEEE80211_ADDR_COPY(nullf->i_addr1, vap->iv_bss->ni_bssid); 8443 IEEE80211_ADDR_COPY(nullf->i_addr2, vif->addr); 8444 IEEE80211_ADDR_COPY(nullf->i_addr3, vap->iv_bss->ni_macaddr); 8445 8446 return (skb); 8447 } 8448 8449 struct wireless_dev * 8450 linuxkpi_ieee80211_vif_to_wdev(struct ieee80211_vif *vif) 8451 { 8452 struct lkpi_vif *lvif; 8453 8454 lvif = VIF_TO_LVIF(vif); 8455 return (&lvif->wdev); 8456 } 8457 8458 void 8459 linuxkpi_ieee80211_connection_loss(struct ieee80211_vif *vif) 8460 { 8461 struct lkpi_vif *lvif; 8462 struct ieee80211vap *vap; 8463 enum ieee80211_state nstate; 8464 int arg; 8465 8466 lvif = VIF_TO_LVIF(vif); 8467 vap = LVIF_TO_VAP(lvif); 8468 8469 /* 8470 * Go to init; otherwise we need to elaborately check state and 8471 * handle accordingly, e.g., if in RUN we could call iv_bmiss. 8472 * Let the statemachine handle all neccessary changes. 8473 */ 8474 nstate = IEEE80211_S_INIT; 8475 arg = 0; /* Not a valid reason. */ 8476 8477 ic_printf(vap->iv_ic, "%s: vif %p vap %p state %s (synched %d, assoc %d " 8478 "beacons %d dtim_period %d)\n", __func__, vif, vap, 8479 ieee80211_state_name[vap->iv_state], 8480 lvif->lvif_bss_synched, vif->cfg.assoc, lvif->beacons, 8481 vif->bss_conf.dtim_period); 8482 ieee80211_new_state(vap, nstate, arg); 8483 } 8484 8485 void 8486 linuxkpi_ieee80211_beacon_loss(struct ieee80211_vif *vif) 8487 { 8488 struct lkpi_vif *lvif; 8489 struct ieee80211vap *vap; 8490 8491 lvif = VIF_TO_LVIF(vif); 8492 vap = LVIF_TO_VAP(lvif); 8493 8494 ic_printf(vap->iv_ic, "%s: vif %p vap %p state %s (synched %d, assoc %d " 8495 "beacons %d dtim_period %d)\n", __func__, vif, vap, 8496 ieee80211_state_name[vap->iv_state], 8497 lvif->lvif_bss_synched, vif->cfg.assoc, lvif->beacons, 8498 vif->bss_conf.dtim_period); 8499 ieee80211_beacon_miss(vap->iv_ic); 8500 } 8501 8502 /* -------------------------------------------------------------------------- */ 8503 8504 void 8505 linuxkpi_ieee80211_stop_queue(struct ieee80211_hw *hw, int qnum) 8506 { 8507 struct lkpi_hw *lhw; 8508 struct lkpi_vif *lvif; 8509 struct ieee80211_vif *vif; 8510 int ac_count, ac; 8511 8512 KASSERT(qnum < hw->queues, ("%s: qnum %d >= hw->queues %d, hw %p\n", 8513 __func__, qnum, hw->queues, hw)); 8514 8515 lhw = wiphy_priv(hw->wiphy); 8516 8517 /* See lkpi_ic_vap_create(). */ 8518 if (hw->queues >= IEEE80211_NUM_ACS) 8519 ac_count = IEEE80211_NUM_ACS; 8520 else 8521 ac_count = 1; 8522 8523 LKPI_80211_LHW_LVIF_LOCK(lhw); 8524 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) { 8525 8526 vif = LVIF_TO_VIF(lvif); 8527 for (ac = 0; ac < ac_count; ac++) { 8528 IMPROVE_TXQ("LOCKING"); 8529 if (qnum == vif->hw_queue[ac]) { 8530 #ifdef LINUXKPI_DEBUG_80211 8531 /* 8532 * For now log this to better understand 8533 * how this is supposed to work. 8534 */ 8535 if (lvif->hw_queue_stopped[ac] && 8536 (linuxkpi_debug_80211 & D80211_IMPROVE_TXQ) != 0) 8537 ic_printf(lhw->ic, "%s:%d: lhw %p hw %p " 8538 "lvif %p vif %p ac %d qnum %d already " 8539 "stopped\n", __func__, __LINE__, 8540 lhw, hw, lvif, vif, ac, qnum); 8541 #endif 8542 lvif->hw_queue_stopped[ac] = true; 8543 } 8544 } 8545 } 8546 LKPI_80211_LHW_LVIF_UNLOCK(lhw); 8547 } 8548 8549 void 8550 linuxkpi_ieee80211_stop_queues(struct ieee80211_hw *hw) 8551 { 8552 int i; 8553 8554 IMPROVE_TXQ("Locking; do we need further info?"); 8555 for (i = 0; i < hw->queues; i++) 8556 linuxkpi_ieee80211_stop_queue(hw, i); 8557 } 8558 8559 8560 static void 8561 lkpi_ieee80211_wake_queues(struct ieee80211_hw *hw, int hwq) 8562 { 8563 struct lkpi_hw *lhw; 8564 struct lkpi_vif *lvif; 8565 struct lkpi_sta *lsta; 8566 int ac_count, ac, tid; 8567 8568 /* See lkpi_ic_vap_create(). */ 8569 if (hw->queues >= IEEE80211_NUM_ACS) 8570 ac_count = IEEE80211_NUM_ACS; 8571 else 8572 ac_count = 1; 8573 8574 lhw = wiphy_priv(hw->wiphy); 8575 8576 IMPROVE_TXQ("Locking"); 8577 LKPI_80211_LHW_LVIF_LOCK(lhw); 8578 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) { 8579 struct ieee80211_vif *vif; 8580 8581 vif = LVIF_TO_VIF(lvif); 8582 for (ac = 0; ac < ac_count; ac++) { 8583 8584 if (hwq == vif->hw_queue[ac]) { 8585 8586 /* XXX-BZ what about software scan? */ 8587 8588 #ifdef LINUXKPI_DEBUG_80211 8589 /* 8590 * For now log this to better understand 8591 * how this is supposed to work. 8592 */ 8593 if (!lvif->hw_queue_stopped[ac] && 8594 (linuxkpi_debug_80211 & D80211_IMPROVE_TXQ) != 0) 8595 ic_printf(lhw->ic, "%s:%d: lhw %p hw %p " 8596 "lvif %p vif %p ac %d hw_q not stopped\n", 8597 __func__, __LINE__, 8598 lhw, hw, lvif, vif, ac); 8599 #endif 8600 lvif->hw_queue_stopped[ac] = false; 8601 8602 rcu_read_lock(); 8603 list_for_each_entry_rcu(lsta, &lvif->lsta_list, lsta_list) { 8604 struct ieee80211_sta *sta; 8605 8606 sta = LSTA_TO_STA(lsta); 8607 for (tid = 0; tid < nitems(sta->txq); tid++) { 8608 struct lkpi_txq *ltxq; 8609 8610 if (sta->txq[tid] == NULL) 8611 continue; 8612 8613 if (sta->txq[tid]->ac != ac) 8614 continue; 8615 8616 ltxq = TXQ_TO_LTXQ(sta->txq[tid]); 8617 if (!ltxq->stopped) 8618 continue; 8619 8620 ltxq->stopped = false; 8621 8622 if (!skb_queue_empty(<xq->skbq)) 8623 lkpi_80211_mo_wake_tx_queue(hw, sta->txq[tid]); 8624 } 8625 } 8626 rcu_read_unlock(); 8627 } 8628 } 8629 } 8630 LKPI_80211_LHW_LVIF_UNLOCK(lhw); 8631 } 8632 8633 static void 8634 lkpi_ieee80211_wake_queues_locked(struct ieee80211_hw *hw) 8635 { 8636 int i; 8637 8638 IMPROVE_TXQ("Is this all/enough here?"); 8639 for (i = 0; i < hw->queues; i++) 8640 lkpi_ieee80211_wake_queues(hw, i); 8641 } 8642 8643 void 8644 linuxkpi_ieee80211_wake_queues(struct ieee80211_hw *hw) 8645 { 8646 struct lkpi_hw *lhw; 8647 unsigned long flags; 8648 8649 lhw = HW_TO_LHW(hw); 8650 8651 spin_lock_irqsave(&lhw->txq_lock, flags); 8652 lkpi_ieee80211_wake_queues_locked(hw); 8653 spin_unlock_irqrestore(&lhw->txq_lock, flags); 8654 } 8655 8656 void 8657 linuxkpi_ieee80211_wake_queue(struct ieee80211_hw *hw, int qnum) 8658 { 8659 struct lkpi_hw *lhw; 8660 unsigned long flags; 8661 8662 KASSERT(qnum < hw->queues, ("%s: qnum %d >= hw->queues %d, hw %p\n", 8663 __func__, qnum, hw->queues, hw)); 8664 8665 lhw = HW_TO_LHW(hw); 8666 8667 spin_lock_irqsave(&lhw->txq_lock, flags); 8668 lkpi_ieee80211_wake_queues(hw, qnum); 8669 spin_unlock_irqrestore(&lhw->txq_lock, flags); 8670 } 8671 8672 /* -------------------------------------------------------------------------- */ 8673 8674 /* This is just hardware queues. */ 8675 /* 8676 * Being called from the driver thus use _bh() locking. 8677 */ 8678 void 8679 linuxkpi_ieee80211_txq_schedule_start(struct ieee80211_hw *hw, uint8_t ac) 8680 { 8681 struct lkpi_hw *lhw; 8682 8683 lhw = HW_TO_LHW(hw); 8684 8685 if (ac >= IEEE80211_NUM_ACS) { 8686 ic_printf(lhw->ic, "%s: ac %u out of bounds.\n", __func__, ac); 8687 return; 8688 } 8689 8690 spin_lock_bh(&lhw->txq_scheduled_lock[ac]); 8691 IMPROVE("check AIRTIME_FAIRNESS"); 8692 if (++lhw->txq_generation[ac] == 0) 8693 lhw->txq_generation[ac]++; 8694 spin_unlock_bh(&lhw->txq_scheduled_lock[ac]); 8695 } 8696 8697 struct ieee80211_txq * 8698 linuxkpi_ieee80211_next_txq(struct ieee80211_hw *hw, uint8_t ac) 8699 { 8700 struct lkpi_hw *lhw; 8701 struct ieee80211_txq *txq; 8702 struct lkpi_txq *ltxq; 8703 8704 lhw = HW_TO_LHW(hw); 8705 txq = NULL; 8706 8707 if (ac >= IEEE80211_NUM_ACS) { 8708 ic_printf(lhw->ic, "%s: ac %u out of bounds.\n", __func__, ac); 8709 return (NULL); 8710 } 8711 8712 spin_lock_bh(&lhw->txq_scheduled_lock[ac]); 8713 8714 /* Check that we are scheduled. */ 8715 if (lhw->txq_generation[ac] == 0) 8716 goto out; 8717 8718 ltxq = TAILQ_FIRST(&lhw->txq_scheduled[ac]); 8719 if (ltxq == NULL) 8720 goto out; 8721 if (ltxq->txq_generation == lhw->txq_generation[ac]) 8722 goto out; 8723 8724 IMPROVE("check AIRTIME_FAIRNESS"); 8725 8726 TAILQ_REMOVE(&lhw->txq_scheduled[ac], ltxq, txq_entry); 8727 ltxq->txq_generation = lhw->txq_generation[ac]; 8728 txq = <xq->txq; 8729 TAILQ_ELEM_INIT(ltxq, txq_entry); 8730 8731 out: 8732 spin_unlock_bh(&lhw->txq_scheduled_lock[ac]); 8733 8734 return (txq); 8735 } 8736 8737 void linuxkpi_ieee80211_schedule_txq(struct ieee80211_hw *hw, 8738 struct ieee80211_txq *txq, bool withoutpkts) 8739 { 8740 struct lkpi_hw *lhw; 8741 struct lkpi_txq *ltxq; 8742 bool ltxq_empty; 8743 8744 ltxq = TXQ_TO_LTXQ(txq); 8745 8746 /* Only schedule if work to do or asked to anyway. */ 8747 LKPI_80211_LTXQ_LOCK(ltxq); 8748 ltxq_empty = skb_queue_empty(<xq->skbq); 8749 LKPI_80211_LTXQ_UNLOCK(ltxq); 8750 if (!withoutpkts && ltxq_empty) 8751 goto out; 8752 8753 lhw = HW_TO_LHW(hw); 8754 spin_lock_bh(&lhw->txq_scheduled_lock[txq->ac]); 8755 /* 8756 * Make sure we do not double-schedule. We do this by checking tqe_prev, 8757 * the previous entry in our tailq. tqe_prev is always valid if this entry 8758 * is queued, tqe_next may be NULL if this is the only element in the list. 8759 */ 8760 if (ltxq->txq_entry.tqe_prev != NULL) 8761 goto unlock; 8762 8763 TAILQ_INSERT_TAIL(&lhw->txq_scheduled[txq->ac], ltxq, txq_entry); 8764 unlock: 8765 spin_unlock_bh(&lhw->txq_scheduled_lock[txq->ac]); 8766 8767 out: 8768 return; 8769 } 8770 8771 /* -------------------------------------------------------------------------- */ 8772 8773 void 8774 linuxkpi_ieee80211_handle_wake_tx_queue(struct ieee80211_hw *hw, 8775 struct ieee80211_txq *txq) 8776 { 8777 struct lkpi_hw *lhw; 8778 struct ieee80211_txq *ntxq; 8779 struct ieee80211_tx_control control; 8780 struct sk_buff *skb; 8781 8782 lhw = HW_TO_LHW(hw); 8783 8784 LKPI_80211_LHW_TXQ_LOCK(lhw); 8785 ieee80211_txq_schedule_start(hw, txq->ac); 8786 do { 8787 ntxq = ieee80211_next_txq(hw, txq->ac); 8788 if (ntxq == NULL) 8789 break; 8790 8791 memset(&control, 0, sizeof(control)); 8792 control.sta = ntxq->sta; 8793 do { 8794 skb = linuxkpi_ieee80211_tx_dequeue(hw, ntxq); 8795 if (skb == NULL) 8796 break; 8797 lkpi_80211_mo_tx(hw, &control, skb); 8798 } while(1); 8799 8800 ieee80211_return_txq(hw, ntxq, false); 8801 } while (1); 8802 ieee80211_txq_schedule_end(hw, txq->ac); 8803 LKPI_80211_LHW_TXQ_UNLOCK(lhw); 8804 } 8805 8806 /* -------------------------------------------------------------------------- */ 8807 8808 struct lkpi_cfg80211_bss { 8809 u_int refcnt; 8810 struct cfg80211_bss bss; 8811 }; 8812 8813 struct lkpi_cfg80211_get_bss_iter_lookup { 8814 struct wiphy *wiphy; 8815 struct linuxkpi_ieee80211_channel *chan; 8816 const uint8_t *bssid; 8817 const uint8_t *ssid; 8818 size_t ssid_len; 8819 enum ieee80211_bss_type bss_type; 8820 enum ieee80211_privacy privacy; 8821 8822 /* 8823 * Something to store a copy of the result as the net80211 scan cache 8824 * is not refoucnted so a scan entry might go away any time. 8825 */ 8826 bool match; 8827 struct cfg80211_bss *bss; 8828 }; 8829 8830 static void 8831 lkpi_cfg80211_get_bss_iterf(void *arg, const struct ieee80211_scan_entry *se) 8832 { 8833 struct lkpi_cfg80211_get_bss_iter_lookup *lookup; 8834 size_t ielen; 8835 8836 lookup = arg; 8837 8838 /* Do not try to find another match. */ 8839 if (lookup->match) 8840 return; 8841 8842 /* Nothing to store result. */ 8843 if (lookup->bss == NULL) 8844 return; 8845 8846 if (lookup->privacy != IEEE80211_PRIVACY_ANY) { 8847 /* if (se->se_capinfo & IEEE80211_CAPINFO_PRIVACY) */ 8848 /* We have no idea what to compare to as the drivers only request ANY */ 8849 return; 8850 } 8851 8852 if (lookup->bss_type != IEEE80211_BSS_TYPE_ANY) { 8853 /* if (se->se_capinfo & (IEEE80211_CAPINFO_IBSS|IEEE80211_CAPINFO_ESS)) */ 8854 /* We have no idea what to compare to as the drivers only request ANY */ 8855 return; 8856 } 8857 8858 if (lookup->chan != NULL) { 8859 struct linuxkpi_ieee80211_channel *chan; 8860 8861 chan = linuxkpi_ieee80211_get_channel(lookup->wiphy, 8862 se->se_chan->ic_freq); 8863 if (chan == NULL || chan != lookup->chan) 8864 return; 8865 } 8866 8867 if (lookup->bssid && !IEEE80211_ADDR_EQ(lookup->bssid, se->se_bssid)) 8868 return; 8869 8870 if (lookup->ssid) { 8871 if (lookup->ssid_len != se->se_ssid[1] || 8872 se->se_ssid[1] == 0) 8873 return; 8874 if (memcmp(lookup->ssid, se->se_ssid+2, lookup->ssid_len) != 0) 8875 return; 8876 } 8877 8878 ielen = se->se_ies.len; 8879 8880 lookup->bss->ies = malloc(sizeof(*lookup->bss->ies) + ielen, 8881 M_LKPI80211, M_NOWAIT | M_ZERO); 8882 if (lookup->bss->ies == NULL) 8883 return; 8884 8885 lookup->bss->ies->data = (uint8_t *)lookup->bss->ies + sizeof(*lookup->bss->ies); 8886 lookup->bss->ies->len = ielen; 8887 if (ielen) 8888 memcpy(lookup->bss->ies->data, se->se_ies.data, ielen); 8889 8890 lookup->match = true; 8891 } 8892 8893 struct cfg80211_bss * 8894 linuxkpi_cfg80211_get_bss(struct wiphy *wiphy, struct linuxkpi_ieee80211_channel *chan, 8895 const uint8_t *bssid, const uint8_t *ssid, size_t ssid_len, 8896 enum ieee80211_bss_type bss_type, enum ieee80211_privacy privacy) 8897 { 8898 struct lkpi_cfg80211_bss *lbss; 8899 struct lkpi_cfg80211_get_bss_iter_lookup lookup; 8900 struct lkpi_hw *lhw; 8901 struct ieee80211vap *vap; 8902 8903 lhw = wiphy_priv(wiphy); 8904 8905 /* Let's hope we can alloc. */ 8906 lbss = malloc(sizeof(*lbss), M_LKPI80211, M_NOWAIT | M_ZERO); 8907 if (lbss == NULL) { 8908 ic_printf(lhw->ic, "%s: alloc failed.\n", __func__); 8909 return (NULL); 8910 } 8911 8912 lookup.wiphy = wiphy; 8913 lookup.chan = chan; 8914 lookup.bssid = bssid; 8915 lookup.ssid = ssid; 8916 lookup.ssid_len = ssid_len; 8917 lookup.bss_type = bss_type; 8918 lookup.privacy = privacy; 8919 lookup.match = false; 8920 lookup.bss = &lbss->bss; 8921 8922 IMPROVE("Iterate over all VAPs comparing perm_addr and addresses?"); 8923 vap = TAILQ_FIRST(&lhw->ic->ic_vaps); 8924 ieee80211_scan_iterate(vap, lkpi_cfg80211_get_bss_iterf, &lookup); 8925 if (!lookup.match) { 8926 free(lbss, M_LKPI80211); 8927 return (NULL); 8928 } 8929 8930 refcount_init(&lbss->refcnt, 1); 8931 return (&lbss->bss); 8932 } 8933 8934 void 8935 linuxkpi_cfg80211_put_bss(struct wiphy *wiphy, struct cfg80211_bss *bss) 8936 { 8937 struct lkpi_cfg80211_bss *lbss; 8938 8939 lbss = container_of(bss, struct lkpi_cfg80211_bss, bss); 8940 8941 /* Free everything again on refcount ... */ 8942 if (refcount_release(&lbss->refcnt)) { 8943 free(lbss->bss.ies, M_LKPI80211); 8944 free(lbss, M_LKPI80211); 8945 } 8946 } 8947 8948 void 8949 linuxkpi_cfg80211_bss_flush(struct wiphy *wiphy) 8950 { 8951 struct lkpi_hw *lhw; 8952 struct ieee80211com *ic; 8953 struct ieee80211vap *vap; 8954 8955 lhw = wiphy_priv(wiphy); 8956 ic = lhw->ic; 8957 8958 /* 8959 * If we haven't called ieee80211_ifattach() yet 8960 * or there is no VAP, there are no scans to flush. 8961 */ 8962 if (ic == NULL || 8963 (lhw->sc_flags & LKPI_MAC80211_DRV_STARTED) == 0) 8964 return; 8965 8966 /* Should only happen on the current one? Not seen it late enough. */ 8967 IEEE80211_LOCK(ic); 8968 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 8969 ieee80211_scan_flush(vap); 8970 IEEE80211_UNLOCK(ic); 8971 } 8972 8973 /* -------------------------------------------------------------------------- */ 8974 8975 /* 8976 * hw->conf get initialized/set in various places for us: 8977 * - linuxkpi_ieee80211_alloc_hw(): flags 8978 * - linuxkpi_ieee80211_ifattach(): chandef 8979 * - lkpi_ic_vap_create(): listen_interval 8980 * - lkpi_ic_set_channel(): chandef, flags 8981 */ 8982 8983 int lkpi_80211_update_chandef(struct ieee80211_hw *hw, 8984 struct ieee80211_chanctx_conf *new) 8985 { 8986 struct cfg80211_chan_def *cd; 8987 uint32_t changed; 8988 int error; 8989 8990 changed = 0; 8991 if (new == NULL || new->def.chan == NULL) 8992 cd = NULL; 8993 else 8994 cd = &new->def; 8995 8996 if (cd && cd->chan != hw->conf.chandef.chan) { 8997 /* Copy; the chan pointer is fine and will stay valid. */ 8998 hw->conf.chandef = *cd; 8999 changed |= IEEE80211_CONF_CHANGE_CHANNEL; 9000 } 9001 IMPROVE("IEEE80211_CONF_CHANGE_PS, IEEE80211_CONF_CHANGE_POWER"); 9002 9003 if (changed == 0) 9004 return (0); 9005 9006 error = lkpi_80211_mo_config(hw, changed); 9007 return (error); 9008 } 9009 9010 /* -------------------------------------------------------------------------- */ 9011 9012 MODULE_VERSION(linuxkpi_wlan, 1); 9013 MODULE_DEPEND(linuxkpi_wlan, linuxkpi, 1, 1, 1); 9014 MODULE_DEPEND(linuxkpi_wlan, wlan, 1, 1, 1); 9015