1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2001 Atsushi Onoe 5 * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting 6 * All rights reserved. 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 ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 /* 31 * IEEE 802.11 generic handler 32 */ 33 #include "opt_wlan.h" 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/malloc.h> 39 #include <sys/socket.h> 40 #include <sys/sbuf.h> 41 42 #include <machine/stdarg.h> 43 44 #include <net/if.h> 45 #include <net/if_var.h> 46 #include <net/if_dl.h> 47 #include <net/if_media.h> 48 #include <net/if_private.h> 49 #include <net/if_types.h> 50 #include <net/ethernet.h> 51 52 #include <net80211/ieee80211_var.h> 53 #include <net80211/ieee80211_regdomain.h> 54 #ifdef IEEE80211_SUPPORT_SUPERG 55 #include <net80211/ieee80211_superg.h> 56 #endif 57 #include <net80211/ieee80211_ratectl.h> 58 #include <net80211/ieee80211_vht.h> 59 60 #include <net/bpf.h> 61 62 const char *ieee80211_phymode_name[IEEE80211_MODE_MAX] = { 63 [IEEE80211_MODE_AUTO] = "auto", 64 [IEEE80211_MODE_11A] = "11a", 65 [IEEE80211_MODE_11B] = "11b", 66 [IEEE80211_MODE_11G] = "11g", 67 [IEEE80211_MODE_FH] = "FH", 68 [IEEE80211_MODE_TURBO_A] = "turboA", 69 [IEEE80211_MODE_TURBO_G] = "turboG", 70 [IEEE80211_MODE_STURBO_A] = "sturboA", 71 [IEEE80211_MODE_HALF] = "half", 72 [IEEE80211_MODE_QUARTER] = "quarter", 73 [IEEE80211_MODE_11NA] = "11na", 74 [IEEE80211_MODE_11NG] = "11ng", 75 [IEEE80211_MODE_VHT_2GHZ] = "11acg", 76 [IEEE80211_MODE_VHT_5GHZ] = "11ac", 77 }; 78 /* map ieee80211_opmode to the corresponding capability bit */ 79 const int ieee80211_opcap[IEEE80211_OPMODE_MAX] = { 80 [IEEE80211_M_IBSS] = IEEE80211_C_IBSS, 81 [IEEE80211_M_WDS] = IEEE80211_C_WDS, 82 [IEEE80211_M_STA] = IEEE80211_C_STA, 83 [IEEE80211_M_AHDEMO] = IEEE80211_C_AHDEMO, 84 [IEEE80211_M_HOSTAP] = IEEE80211_C_HOSTAP, 85 [IEEE80211_M_MONITOR] = IEEE80211_C_MONITOR, 86 #ifdef IEEE80211_SUPPORT_MESH 87 [IEEE80211_M_MBSS] = IEEE80211_C_MBSS, 88 #endif 89 }; 90 91 const uint8_t ieee80211broadcastaddr[IEEE80211_ADDR_LEN] = 92 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 93 94 static void ieee80211_syncflag_locked(struct ieee80211com *ic, int flag); 95 static void ieee80211_syncflag_ht_locked(struct ieee80211com *ic, int flag); 96 static void ieee80211_syncflag_ext_locked(struct ieee80211com *ic, int flag); 97 static void ieee80211_syncflag_vht_locked(struct ieee80211com *ic, int flag); 98 static int ieee80211_media_setup(struct ieee80211com *ic, 99 struct ifmedia *media, int caps, int addsta, 100 ifm_change_cb_t media_change, ifm_stat_cb_t media_stat); 101 static int media_status(enum ieee80211_opmode, 102 const struct ieee80211_channel *); 103 static uint64_t ieee80211_get_counter(struct ifnet *, ift_counter); 104 105 MALLOC_DEFINE(M_80211_VAP, "80211vap", "802.11 vap state"); 106 107 /* 108 * Default supported rates for 802.11 operation (in IEEE .5Mb units). 109 */ 110 #define B(r) ((r) | IEEE80211_RATE_BASIC) 111 static const struct ieee80211_rateset ieee80211_rateset_11a = 112 { 8, { B(12), 18, B(24), 36, B(48), 72, 96, 108 } }; 113 static const struct ieee80211_rateset ieee80211_rateset_half = 114 { 8, { B(6), 9, B(12), 18, B(24), 36, 48, 54 } }; 115 static const struct ieee80211_rateset ieee80211_rateset_quarter = 116 { 8, { B(3), 4, B(6), 9, B(12), 18, 24, 27 } }; 117 static const struct ieee80211_rateset ieee80211_rateset_11b = 118 { 4, { B(2), B(4), B(11), B(22) } }; 119 /* NB: OFDM rates are handled specially based on mode */ 120 static const struct ieee80211_rateset ieee80211_rateset_11g = 121 { 12, { B(2), B(4), B(11), B(22), 12, 18, 24, 36, 48, 72, 96, 108 } }; 122 #undef B 123 124 static int set_vht_extchan(struct ieee80211_channel *c); 125 126 /* 127 * Fill in 802.11 available channel set, mark 128 * all available channels as active, and pick 129 * a default channel if not already specified. 130 */ 131 void 132 ieee80211_chan_init(struct ieee80211com *ic) 133 { 134 #define DEFAULTRATES(m, def) do { \ 135 if (ic->ic_sup_rates[m].rs_nrates == 0) \ 136 ic->ic_sup_rates[m] = def; \ 137 } while (0) 138 struct ieee80211_channel *c; 139 int i; 140 141 KASSERT(0 < ic->ic_nchans && ic->ic_nchans <= IEEE80211_CHAN_MAX, 142 ("invalid number of channels specified: %u", ic->ic_nchans)); 143 memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail)); 144 memset(ic->ic_modecaps, 0, sizeof(ic->ic_modecaps)); 145 setbit(ic->ic_modecaps, IEEE80211_MODE_AUTO); 146 for (i = 0; i < ic->ic_nchans; i++) { 147 c = &ic->ic_channels[i]; 148 KASSERT(c->ic_flags != 0, ("channel with no flags")); 149 /* 150 * Help drivers that work only with frequencies by filling 151 * in IEEE channel #'s if not already calculated. Note this 152 * mimics similar work done in ieee80211_setregdomain when 153 * changing regulatory state. 154 */ 155 if (c->ic_ieee == 0) 156 c->ic_ieee = ieee80211_mhz2ieee(c->ic_freq,c->ic_flags); 157 158 /* 159 * Setup the HT40/VHT40 upper/lower bits. 160 * The VHT80/... math is done elsewhere. 161 */ 162 if (IEEE80211_IS_CHAN_HT40(c) && c->ic_extieee == 0) 163 c->ic_extieee = ieee80211_mhz2ieee(c->ic_freq + 164 (IEEE80211_IS_CHAN_HT40U(c) ? 20 : -20), 165 c->ic_flags); 166 167 /* Update VHT math */ 168 /* 169 * XXX VHT again, note that this assumes VHT80/... channels 170 * are legit already. 171 */ 172 set_vht_extchan(c); 173 174 /* default max tx power to max regulatory */ 175 if (c->ic_maxpower == 0) 176 c->ic_maxpower = 2*c->ic_maxregpower; 177 setbit(ic->ic_chan_avail, c->ic_ieee); 178 /* 179 * Identify mode capabilities. 180 */ 181 if (IEEE80211_IS_CHAN_A(c)) 182 setbit(ic->ic_modecaps, IEEE80211_MODE_11A); 183 if (IEEE80211_IS_CHAN_B(c)) 184 setbit(ic->ic_modecaps, IEEE80211_MODE_11B); 185 if (IEEE80211_IS_CHAN_ANYG(c)) 186 setbit(ic->ic_modecaps, IEEE80211_MODE_11G); 187 if (IEEE80211_IS_CHAN_FHSS(c)) 188 setbit(ic->ic_modecaps, IEEE80211_MODE_FH); 189 if (IEEE80211_IS_CHAN_108A(c)) 190 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_A); 191 if (IEEE80211_IS_CHAN_108G(c)) 192 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_G); 193 if (IEEE80211_IS_CHAN_ST(c)) 194 setbit(ic->ic_modecaps, IEEE80211_MODE_STURBO_A); 195 if (IEEE80211_IS_CHAN_HALF(c)) 196 setbit(ic->ic_modecaps, IEEE80211_MODE_HALF); 197 if (IEEE80211_IS_CHAN_QUARTER(c)) 198 setbit(ic->ic_modecaps, IEEE80211_MODE_QUARTER); 199 if (IEEE80211_IS_CHAN_HTA(c)) 200 setbit(ic->ic_modecaps, IEEE80211_MODE_11NA); 201 if (IEEE80211_IS_CHAN_HTG(c)) 202 setbit(ic->ic_modecaps, IEEE80211_MODE_11NG); 203 if (IEEE80211_IS_CHAN_VHTA(c)) 204 setbit(ic->ic_modecaps, IEEE80211_MODE_VHT_5GHZ); 205 if (IEEE80211_IS_CHAN_VHTG(c)) 206 setbit(ic->ic_modecaps, IEEE80211_MODE_VHT_2GHZ); 207 } 208 /* initialize candidate channels to all available */ 209 memcpy(ic->ic_chan_active, ic->ic_chan_avail, 210 sizeof(ic->ic_chan_avail)); 211 212 /* sort channel table to allow lookup optimizations */ 213 ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans); 214 215 /* invalidate any previous state */ 216 ic->ic_bsschan = IEEE80211_CHAN_ANYC; 217 ic->ic_prevchan = NULL; 218 ic->ic_csa_newchan = NULL; 219 /* arbitrarily pick the first channel */ 220 ic->ic_curchan = &ic->ic_channels[0]; 221 ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan); 222 223 /* fillin well-known rate sets if driver has not specified */ 224 DEFAULTRATES(IEEE80211_MODE_11B, ieee80211_rateset_11b); 225 DEFAULTRATES(IEEE80211_MODE_11G, ieee80211_rateset_11g); 226 DEFAULTRATES(IEEE80211_MODE_11A, ieee80211_rateset_11a); 227 DEFAULTRATES(IEEE80211_MODE_TURBO_A, ieee80211_rateset_11a); 228 DEFAULTRATES(IEEE80211_MODE_TURBO_G, ieee80211_rateset_11g); 229 DEFAULTRATES(IEEE80211_MODE_STURBO_A, ieee80211_rateset_11a); 230 DEFAULTRATES(IEEE80211_MODE_HALF, ieee80211_rateset_half); 231 DEFAULTRATES(IEEE80211_MODE_QUARTER, ieee80211_rateset_quarter); 232 DEFAULTRATES(IEEE80211_MODE_11NA, ieee80211_rateset_11a); 233 DEFAULTRATES(IEEE80211_MODE_11NG, ieee80211_rateset_11g); 234 DEFAULTRATES(IEEE80211_MODE_VHT_2GHZ, ieee80211_rateset_11g); 235 DEFAULTRATES(IEEE80211_MODE_VHT_5GHZ, ieee80211_rateset_11a); 236 237 /* 238 * Setup required information to fill the mcsset field, if driver did 239 * not. Assume a 2T2R setup for historic reasons. 240 */ 241 if (ic->ic_rxstream == 0) 242 ic->ic_rxstream = 2; 243 if (ic->ic_txstream == 0) 244 ic->ic_txstream = 2; 245 246 ieee80211_init_suphtrates(ic); 247 248 /* 249 * Set auto mode to reset active channel state and any desired channel. 250 */ 251 (void) ieee80211_setmode(ic, IEEE80211_MODE_AUTO); 252 #undef DEFAULTRATES 253 } 254 255 static void 256 null_update_mcast(struct ieee80211com *ic) 257 { 258 259 ic_printf(ic, "need multicast update callback\n"); 260 } 261 262 static void 263 null_update_promisc(struct ieee80211com *ic) 264 { 265 266 ic_printf(ic, "need promiscuous mode update callback\n"); 267 } 268 269 static void 270 null_update_chw(struct ieee80211com *ic) 271 { 272 273 ic_printf(ic, "%s: need callback\n", __func__); 274 } 275 276 int 277 ic_printf(struct ieee80211com *ic, const char * fmt, ...) 278 { 279 va_list ap; 280 int retval; 281 282 retval = printf("%s: ", ic->ic_name); 283 va_start(ap, fmt); 284 retval += vprintf(fmt, ap); 285 va_end(ap); 286 return (retval); 287 } 288 289 static LIST_HEAD(, ieee80211com) ic_head = LIST_HEAD_INITIALIZER(ic_head); 290 static struct mtx ic_list_mtx; 291 MTX_SYSINIT(ic_list, &ic_list_mtx, "ieee80211com list", MTX_DEF); 292 293 static int 294 sysctl_ieee80211coms(SYSCTL_HANDLER_ARGS) 295 { 296 struct ieee80211com *ic; 297 struct sbuf sb; 298 char *sp; 299 int error; 300 301 error = sysctl_wire_old_buffer(req, 0); 302 if (error) 303 return (error); 304 sbuf_new_for_sysctl(&sb, NULL, 8, req); 305 sbuf_clear_flags(&sb, SBUF_INCLUDENUL); 306 sp = ""; 307 mtx_lock(&ic_list_mtx); 308 LIST_FOREACH(ic, &ic_head, ic_next) { 309 sbuf_printf(&sb, "%s%s", sp, ic->ic_name); 310 sp = " "; 311 } 312 mtx_unlock(&ic_list_mtx); 313 error = sbuf_finish(&sb); 314 sbuf_delete(&sb); 315 return (error); 316 } 317 318 SYSCTL_PROC(_net_wlan, OID_AUTO, devices, 319 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0, 320 sysctl_ieee80211coms, "A", "names of available 802.11 devices"); 321 322 /* 323 * Attach/setup the common net80211 state. Called by 324 * the driver on attach to prior to creating any vap's. 325 */ 326 void 327 ieee80211_ifattach(struct ieee80211com *ic) 328 { 329 330 IEEE80211_LOCK_INIT(ic, ic->ic_name); 331 IEEE80211_TX_LOCK_INIT(ic, ic->ic_name); 332 TAILQ_INIT(&ic->ic_vaps); 333 334 /* Create a taskqueue for all state changes */ 335 ic->ic_tq = taskqueue_create("ic_taskq", 336 IEEE80211_M_WAITOK | IEEE80211_M_ZERO, 337 taskqueue_thread_enqueue, &ic->ic_tq); 338 taskqueue_start_threads(&ic->ic_tq, 1, PI_NET, "%s net80211 taskq", 339 ic->ic_name); 340 ic->ic_ierrors = counter_u64_alloc(IEEE80211_M_WAITOK); 341 ic->ic_oerrors = counter_u64_alloc(IEEE80211_M_WAITOK); 342 /* 343 * Fill in 802.11 available channel set, mark all 344 * available channels as active, and pick a default 345 * channel if not already specified. 346 */ 347 ieee80211_chan_init(ic); 348 349 ic->ic_update_mcast = null_update_mcast; 350 ic->ic_update_promisc = null_update_promisc; 351 ic->ic_update_chw = null_update_chw; 352 353 ic->ic_hash_key = arc4random(); 354 ic->ic_bintval = IEEE80211_BINTVAL_DEFAULT; 355 ic->ic_lintval = ic->ic_bintval; 356 ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX; 357 358 ieee80211_crypto_attach(ic); 359 ieee80211_node_attach(ic); 360 ieee80211_power_attach(ic); 361 ieee80211_proto_attach(ic); 362 #ifdef IEEE80211_SUPPORT_SUPERG 363 ieee80211_superg_attach(ic); 364 #endif 365 ieee80211_ht_attach(ic); 366 ieee80211_vht_attach(ic); 367 ieee80211_scan_attach(ic); 368 ieee80211_regdomain_attach(ic); 369 ieee80211_dfs_attach(ic); 370 371 ieee80211_sysctl_attach(ic); 372 373 mtx_lock(&ic_list_mtx); 374 LIST_INSERT_HEAD(&ic_head, ic, ic_next); 375 mtx_unlock(&ic_list_mtx); 376 } 377 378 /* 379 * Detach net80211 state on device detach. Tear down 380 * all vap's and reclaim all common state prior to the 381 * device state going away. Note we may call back into 382 * driver; it must be prepared for this. 383 */ 384 void 385 ieee80211_ifdetach(struct ieee80211com *ic) 386 { 387 struct ieee80211vap *vap; 388 389 /* 390 * We use this as an indicator that ifattach never had a chance to be 391 * called, e.g. early driver attach failed and ifdetach was called 392 * during subsequent detach. Never fear, for we have nothing to do 393 * here. 394 */ 395 if (ic->ic_tq == NULL) 396 return; 397 398 mtx_lock(&ic_list_mtx); 399 LIST_REMOVE(ic, ic_next); 400 mtx_unlock(&ic_list_mtx); 401 402 taskqueue_drain(taskqueue_thread, &ic->ic_restart_task); 403 404 /* 405 * The VAP is responsible for setting and clearing 406 * the VIMAGE context. 407 */ 408 while ((vap = TAILQ_FIRST(&ic->ic_vaps)) != NULL) { 409 ieee80211_com_vdetach(vap); 410 ieee80211_vap_destroy(vap); 411 } 412 ieee80211_waitfor_parent(ic); 413 414 ieee80211_sysctl_detach(ic); 415 ieee80211_dfs_detach(ic); 416 ieee80211_regdomain_detach(ic); 417 ieee80211_scan_detach(ic); 418 #ifdef IEEE80211_SUPPORT_SUPERG 419 ieee80211_superg_detach(ic); 420 #endif 421 ieee80211_vht_detach(ic); 422 ieee80211_ht_detach(ic); 423 /* NB: must be called before ieee80211_node_detach */ 424 ieee80211_proto_detach(ic); 425 ieee80211_crypto_detach(ic); 426 ieee80211_power_detach(ic); 427 ieee80211_node_detach(ic); 428 429 counter_u64_free(ic->ic_ierrors); 430 counter_u64_free(ic->ic_oerrors); 431 432 taskqueue_free(ic->ic_tq); 433 IEEE80211_TX_LOCK_DESTROY(ic); 434 IEEE80211_LOCK_DESTROY(ic); 435 } 436 437 /* 438 * Called by drivers during attach to set the supported 439 * cipher set for software encryption. 440 */ 441 void 442 ieee80211_set_software_ciphers(struct ieee80211com *ic, 443 uint32_t cipher_suite) 444 { 445 ieee80211_crypto_set_supported_software_ciphers(ic, cipher_suite); 446 } 447 448 /* 449 * Called by drivers during attach to set the supported 450 * cipher set for hardware encryption. 451 */ 452 void 453 ieee80211_set_hardware_ciphers(struct ieee80211com *ic, 454 uint32_t cipher_suite) 455 { 456 ieee80211_crypto_set_supported_hardware_ciphers(ic, cipher_suite); 457 } 458 459 /* 460 * Called by drivers during attach to set the supported 461 * key management suites by the driver/hardware. 462 */ 463 void 464 ieee80211_set_driver_keymgmt_suites(struct ieee80211com *ic, 465 uint32_t keymgmt_set) 466 { 467 ieee80211_crypto_set_supported_driver_keymgmt(ic, 468 keymgmt_set); 469 } 470 471 struct ieee80211com * 472 ieee80211_find_com(const char *name) 473 { 474 struct ieee80211com *ic; 475 476 mtx_lock(&ic_list_mtx); 477 LIST_FOREACH(ic, &ic_head, ic_next) 478 if (strcmp(ic->ic_name, name) == 0) 479 break; 480 mtx_unlock(&ic_list_mtx); 481 482 return (ic); 483 } 484 485 void 486 ieee80211_iterate_coms(ieee80211_com_iter_func *f, void *arg) 487 { 488 struct ieee80211com *ic; 489 490 mtx_lock(&ic_list_mtx); 491 LIST_FOREACH(ic, &ic_head, ic_next) 492 (*f)(arg, ic); 493 mtx_unlock(&ic_list_mtx); 494 } 495 496 /* 497 * Default reset method for use with the ioctl support. This 498 * method is invoked after any state change in the 802.11 499 * layer that should be propagated to the hardware but not 500 * require re-initialization of the 802.11 state machine (e.g 501 * rescanning for an ap). We always return ENETRESET which 502 * should cause the driver to re-initialize the device. Drivers 503 * can override this method to implement more optimized support. 504 */ 505 static int 506 default_reset(struct ieee80211vap *vap, u_long cmd) 507 { 508 return ENETRESET; 509 } 510 511 /* 512 * Default for updating the VAP default TX key index. 513 * 514 * Drivers that support TX offload as well as hardware encryption offload 515 * may need to be informed of key index changes separate from the key 516 * update. 517 */ 518 static void 519 default_update_deftxkey(struct ieee80211vap *vap, ieee80211_keyix kid) 520 { 521 522 /* XXX assert validity */ 523 /* XXX assert we're in a key update block */ 524 vap->iv_def_txkey = kid; 525 } 526 527 /* 528 * Add underlying device errors to vap errors. 529 */ 530 static uint64_t 531 ieee80211_get_counter(struct ifnet *ifp, ift_counter cnt) 532 { 533 struct ieee80211vap *vap = ifp->if_softc; 534 struct ieee80211com *ic = vap->iv_ic; 535 uint64_t rv; 536 537 rv = if_get_counter_default(ifp, cnt); 538 switch (cnt) { 539 case IFCOUNTER_OERRORS: 540 rv += counter_u64_fetch(ic->ic_oerrors); 541 break; 542 case IFCOUNTER_IERRORS: 543 rv += counter_u64_fetch(ic->ic_ierrors); 544 break; 545 default: 546 break; 547 } 548 549 return (rv); 550 } 551 552 /* 553 * Prepare a vap for use. Drivers use this call to 554 * setup net80211 state in new vap's prior attaching 555 * them with ieee80211_vap_attach (below). 556 */ 557 int 558 ieee80211_vap_setup(struct ieee80211com *ic, struct ieee80211vap *vap, 559 const char name[IFNAMSIZ], int unit, enum ieee80211_opmode opmode, 560 int flags, const uint8_t bssid[IEEE80211_ADDR_LEN]) 561 { 562 struct ifnet *ifp; 563 564 ifp = if_alloc(IFT_ETHER); 565 if_initname(ifp, name, unit); 566 ifp->if_softc = vap; /* back pointer */ 567 if_setflags(ifp, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST); 568 ifp->if_transmit = ieee80211_vap_transmit; 569 ifp->if_qflush = ieee80211_vap_qflush; 570 ifp->if_ioctl = ieee80211_ioctl; 571 ifp->if_init = ieee80211_init; 572 ifp->if_get_counter = ieee80211_get_counter; 573 574 vap->iv_ifp = ifp; 575 vap->iv_ic = ic; 576 vap->iv_flags = ic->ic_flags; /* propagate common flags */ 577 vap->iv_flags_ext = ic->ic_flags_ext; 578 vap->iv_flags_ven = ic->ic_flags_ven; 579 vap->iv_caps = ic->ic_caps &~ IEEE80211_C_OPMODE; 580 581 /* 11n capabilities - XXX methodize */ 582 vap->iv_htcaps = ic->ic_htcaps; 583 vap->iv_htextcaps = ic->ic_htextcaps; 584 585 /* 11ac capabilities - XXX methodize */ 586 vap->iv_vht_cap.vht_cap_info = ic->ic_vht_cap.vht_cap_info; 587 vap->iv_vhtextcaps = ic->ic_vhtextcaps; 588 589 vap->iv_opmode = opmode; 590 vap->iv_caps |= ieee80211_opcap[opmode]; 591 IEEE80211_ADDR_COPY(vap->iv_myaddr, ic->ic_macaddr); 592 switch (opmode) { 593 case IEEE80211_M_WDS: 594 /* 595 * WDS links must specify the bssid of the far end. 596 * For legacy operation this is a static relationship. 597 * For non-legacy operation the station must associate 598 * and be authorized to pass traffic. Plumbing the 599 * vap to the proper node happens when the vap 600 * transitions to RUN state. 601 */ 602 IEEE80211_ADDR_COPY(vap->iv_des_bssid, bssid); 603 vap->iv_flags |= IEEE80211_F_DESBSSID; 604 if (flags & IEEE80211_CLONE_WDSLEGACY) 605 vap->iv_flags_ext |= IEEE80211_FEXT_WDSLEGACY; 606 break; 607 #ifdef IEEE80211_SUPPORT_TDMA 608 case IEEE80211_M_AHDEMO: 609 if (flags & IEEE80211_CLONE_TDMA) { 610 /* NB: checked before clone operation allowed */ 611 KASSERT(ic->ic_caps & IEEE80211_C_TDMA, 612 ("not TDMA capable, ic_caps 0x%x", ic->ic_caps)); 613 /* 614 * Propagate TDMA capability to mark vap; this 615 * cannot be removed and is used to distinguish 616 * regular ahdemo operation from ahdemo+tdma. 617 */ 618 vap->iv_caps |= IEEE80211_C_TDMA; 619 } 620 break; 621 #endif 622 default: 623 break; 624 } 625 /* auto-enable s/w beacon miss support */ 626 if (flags & IEEE80211_CLONE_NOBEACONS) 627 vap->iv_flags_ext |= IEEE80211_FEXT_SWBMISS; 628 /* auto-generated or user supplied MAC address */ 629 if (flags & (IEEE80211_CLONE_BSSID|IEEE80211_CLONE_MACADDR)) 630 vap->iv_flags_ext |= IEEE80211_FEXT_UNIQMAC; 631 /* 632 * Enable various functionality by default if we're 633 * capable; the driver can override us if it knows better. 634 */ 635 if (vap->iv_caps & IEEE80211_C_WME) 636 vap->iv_flags |= IEEE80211_F_WME; 637 if (vap->iv_caps & IEEE80211_C_BURST) 638 vap->iv_flags |= IEEE80211_F_BURST; 639 /* NB: bg scanning only makes sense for station mode right now */ 640 if (vap->iv_opmode == IEEE80211_M_STA && 641 (vap->iv_caps & IEEE80211_C_BGSCAN)) 642 vap->iv_flags |= IEEE80211_F_BGSCAN; 643 vap->iv_flags |= IEEE80211_F_DOTH; /* XXX no cap, just ena */ 644 /* NB: DFS support only makes sense for ap mode right now */ 645 if (vap->iv_opmode == IEEE80211_M_HOSTAP && 646 (vap->iv_caps & IEEE80211_C_DFS)) 647 vap->iv_flags_ext |= IEEE80211_FEXT_DFS; 648 /* NB: only flip on U-APSD for hostap/sta for now */ 649 if ((vap->iv_opmode == IEEE80211_M_STA) 650 || (vap->iv_opmode == IEEE80211_M_HOSTAP)) { 651 if (vap->iv_caps & IEEE80211_C_UAPSD) 652 vap->iv_flags_ext |= IEEE80211_FEXT_UAPSD; 653 } 654 655 vap->iv_des_chan = IEEE80211_CHAN_ANYC; /* any channel is ok */ 656 vap->iv_bmissthreshold = IEEE80211_HWBMISS_DEFAULT; 657 vap->iv_dtim_period = IEEE80211_DTIM_DEFAULT; 658 /* 659 * Install a default reset method for the ioctl support; 660 * the driver can override this. 661 */ 662 vap->iv_reset = default_reset; 663 664 /* 665 * Install a default crypto key update method, the driver 666 * can override this. 667 */ 668 vap->iv_update_deftxkey = default_update_deftxkey; 669 670 ieee80211_sysctl_vattach(vap); 671 ieee80211_crypto_vattach(vap); 672 ieee80211_node_vattach(vap); 673 ieee80211_power_vattach(vap); 674 ieee80211_proto_vattach(vap); 675 #ifdef IEEE80211_SUPPORT_SUPERG 676 ieee80211_superg_vattach(vap); 677 #endif 678 ieee80211_ht_vattach(vap); 679 ieee80211_vht_vattach(vap); 680 ieee80211_scan_vattach(vap); 681 ieee80211_regdomain_vattach(vap); 682 ieee80211_radiotap_vattach(vap); 683 ieee80211_vap_reset_erp(vap); 684 ieee80211_ratectl_set(vap, IEEE80211_RATECTL_NONE); 685 686 return 0; 687 } 688 689 /* 690 * Activate a vap. State should have been prepared with a 691 * call to ieee80211_vap_setup and by the driver. On return 692 * from this call the vap is ready for use. 693 */ 694 int 695 ieee80211_vap_attach(struct ieee80211vap *vap, ifm_change_cb_t media_change, 696 ifm_stat_cb_t media_stat, const uint8_t macaddr[IEEE80211_ADDR_LEN]) 697 { 698 struct ifnet *ifp = vap->iv_ifp; 699 struct ieee80211com *ic = vap->iv_ic; 700 struct ifmediareq imr; 701 int maxrate; 702 703 IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, 704 "%s: %s parent %s flags 0x%x flags_ext 0x%x\n", 705 __func__, ieee80211_opmode_name[vap->iv_opmode], 706 ic->ic_name, vap->iv_flags, vap->iv_flags_ext); 707 708 /* 709 * Do late attach work that cannot happen until after 710 * the driver has had a chance to override defaults. 711 */ 712 ieee80211_node_latevattach(vap); 713 ieee80211_power_latevattach(vap); 714 715 maxrate = ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps, 716 vap->iv_opmode == IEEE80211_M_STA, media_change, media_stat); 717 ieee80211_media_status(ifp, &imr); 718 /* NB: strip explicit mode; we're actually in autoselect */ 719 ifmedia_set(&vap->iv_media, 720 imr.ifm_active &~ (IFM_MMASK | IFM_IEEE80211_TURBO)); 721 if (maxrate) 722 ifp->if_baudrate = IF_Mbps(maxrate); 723 724 ether_ifattach(ifp, macaddr); 725 /* Do initial MAC address sync */ 726 ieee80211_vap_copy_mac_address(vap); 727 /* hook output method setup by ether_ifattach */ 728 vap->iv_output = ifp->if_output; 729 ifp->if_output = ieee80211_output; 730 /* NB: if_mtu set by ether_ifattach to ETHERMTU */ 731 732 IEEE80211_LOCK(ic); 733 TAILQ_INSERT_TAIL(&ic->ic_vaps, vap, iv_next); 734 ieee80211_syncflag_locked(ic, IEEE80211_F_WME); 735 #ifdef IEEE80211_SUPPORT_SUPERG 736 ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP); 737 #endif 738 ieee80211_syncflag_locked(ic, IEEE80211_F_PCF); 739 ieee80211_syncflag_locked(ic, IEEE80211_F_BURST); 740 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT); 741 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40); 742 743 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_VHT); 744 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT40); 745 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT80); 746 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT160); 747 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT80P80); 748 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_STBC_TX); 749 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_STBC_RX); 750 IEEE80211_UNLOCK(ic); 751 752 return 1; 753 } 754 755 /* 756 * Tear down vap state and reclaim the ifnet. 757 * The driver is assumed to have prepared for 758 * this; e.g. by turning off interrupts for the 759 * underlying device. 760 */ 761 void 762 ieee80211_vap_detach(struct ieee80211vap *vap) 763 { 764 struct ieee80211com *ic = vap->iv_ic; 765 struct ifnet *ifp = vap->iv_ifp; 766 int i; 767 768 CURVNET_SET(ifp->if_vnet); 769 770 IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s parent %s\n", 771 __func__, ieee80211_opmode_name[vap->iv_opmode], ic->ic_name); 772 773 /* NB: bpfdetach is called by ether_ifdetach and claims all taps */ 774 ether_ifdetach(ifp); 775 776 ieee80211_stop(vap); 777 778 /* 779 * Flush any deferred vap tasks. 780 */ 781 for (i = 0; i < NET80211_IV_NSTATE_NUM; i++) 782 ieee80211_draintask(ic, &vap->iv_nstate_task[i]); 783 ieee80211_draintask(ic, &vap->iv_swbmiss_task); 784 ieee80211_draintask(ic, &vap->iv_wme_task); 785 ieee80211_draintask(ic, &ic->ic_parent_task); 786 787 /* XXX band-aid until ifnet handles this for us */ 788 taskqueue_drain(taskqueue_swi, &ifp->if_linktask); 789 790 IEEE80211_LOCK(ic); 791 KASSERT(vap->iv_state == IEEE80211_S_INIT , ("vap still running")); 792 TAILQ_REMOVE(&ic->ic_vaps, vap, iv_next); 793 ieee80211_syncflag_locked(ic, IEEE80211_F_WME); 794 #ifdef IEEE80211_SUPPORT_SUPERG 795 ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP); 796 #endif 797 ieee80211_syncflag_locked(ic, IEEE80211_F_PCF); 798 ieee80211_syncflag_locked(ic, IEEE80211_F_BURST); 799 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT); 800 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40); 801 802 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_VHT); 803 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT40); 804 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT80); 805 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT160); 806 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_USEVHT80P80); 807 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_STBC_TX); 808 ieee80211_syncflag_vht_locked(ic, IEEE80211_FVHT_STBC_RX); 809 810 /* NB: this handles the bpfdetach done below */ 811 ieee80211_syncflag_ext_locked(ic, IEEE80211_FEXT_BPF); 812 if (vap->iv_ifflags & IFF_PROMISC) 813 ieee80211_promisc(vap, false); 814 if (vap->iv_ifflags & IFF_ALLMULTI) 815 ieee80211_allmulti(vap, false); 816 IEEE80211_UNLOCK(ic); 817 818 ifmedia_removeall(&vap->iv_media); 819 820 ieee80211_radiotap_vdetach(vap); 821 ieee80211_regdomain_vdetach(vap); 822 ieee80211_scan_vdetach(vap); 823 #ifdef IEEE80211_SUPPORT_SUPERG 824 ieee80211_superg_vdetach(vap); 825 #endif 826 ieee80211_vht_vdetach(vap); 827 ieee80211_ht_vdetach(vap); 828 /* NB: must be before ieee80211_node_vdetach */ 829 ieee80211_proto_vdetach(vap); 830 ieee80211_crypto_vdetach(vap); 831 ieee80211_power_vdetach(vap); 832 ieee80211_node_vdetach(vap); 833 ieee80211_sysctl_vdetach(vap); 834 835 if_free(ifp); 836 837 CURVNET_RESTORE(); 838 } 839 840 /* 841 * Count number of vaps in promisc, and issue promisc on 842 * parent respectively. 843 */ 844 void 845 ieee80211_promisc(struct ieee80211vap *vap, bool on) 846 { 847 struct ieee80211com *ic = vap->iv_ic; 848 849 IEEE80211_LOCK_ASSERT(ic); 850 851 if (on) { 852 if (++ic->ic_promisc == 1) 853 ieee80211_runtask(ic, &ic->ic_promisc_task); 854 } else { 855 KASSERT(ic->ic_promisc > 0, ("%s: ic %p not promisc", 856 __func__, ic)); 857 if (--ic->ic_promisc == 0) 858 ieee80211_runtask(ic, &ic->ic_promisc_task); 859 } 860 } 861 862 /* 863 * Count number of vaps in allmulti, and issue allmulti on 864 * parent respectively. 865 */ 866 void 867 ieee80211_allmulti(struct ieee80211vap *vap, bool on) 868 { 869 struct ieee80211com *ic = vap->iv_ic; 870 871 IEEE80211_LOCK_ASSERT(ic); 872 873 if (on) { 874 if (++ic->ic_allmulti == 1) 875 ieee80211_runtask(ic, &ic->ic_mcast_task); 876 } else { 877 KASSERT(ic->ic_allmulti > 0, ("%s: ic %p not allmulti", 878 __func__, ic)); 879 if (--ic->ic_allmulti == 0) 880 ieee80211_runtask(ic, &ic->ic_mcast_task); 881 } 882 } 883 884 /* 885 * Synchronize flag bit state in the com structure 886 * according to the state of all vap's. This is used, 887 * for example, to handle state changes via ioctls. 888 */ 889 static void 890 ieee80211_syncflag_locked(struct ieee80211com *ic, int flag) 891 { 892 struct ieee80211vap *vap; 893 int bit; 894 895 IEEE80211_LOCK_ASSERT(ic); 896 897 bit = 0; 898 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 899 if (vap->iv_flags & flag) { 900 bit = 1; 901 break; 902 } 903 if (bit) 904 ic->ic_flags |= flag; 905 else 906 ic->ic_flags &= ~flag; 907 } 908 909 void 910 ieee80211_syncflag(struct ieee80211vap *vap, int flag) 911 { 912 struct ieee80211com *ic = vap->iv_ic; 913 914 IEEE80211_LOCK(ic); 915 if (flag < 0) { 916 flag = -flag; 917 vap->iv_flags &= ~flag; 918 } else 919 vap->iv_flags |= flag; 920 ieee80211_syncflag_locked(ic, flag); 921 IEEE80211_UNLOCK(ic); 922 } 923 924 /* 925 * Synchronize flags_ht bit state in the com structure 926 * according to the state of all vap's. This is used, 927 * for example, to handle state changes via ioctls. 928 */ 929 static void 930 ieee80211_syncflag_ht_locked(struct ieee80211com *ic, int flag) 931 { 932 struct ieee80211vap *vap; 933 int bit; 934 935 IEEE80211_LOCK_ASSERT(ic); 936 937 bit = 0; 938 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 939 if (vap->iv_flags_ht & flag) { 940 bit = 1; 941 break; 942 } 943 if (bit) 944 ic->ic_flags_ht |= flag; 945 else 946 ic->ic_flags_ht &= ~flag; 947 } 948 949 void 950 ieee80211_syncflag_ht(struct ieee80211vap *vap, int flag) 951 { 952 struct ieee80211com *ic = vap->iv_ic; 953 954 IEEE80211_LOCK(ic); 955 if (flag < 0) { 956 flag = -flag; 957 vap->iv_flags_ht &= ~flag; 958 } else 959 vap->iv_flags_ht |= flag; 960 ieee80211_syncflag_ht_locked(ic, flag); 961 IEEE80211_UNLOCK(ic); 962 } 963 964 /* 965 * Synchronize flags_vht bit state in the com structure 966 * according to the state of all vap's. This is used, 967 * for example, to handle state changes via ioctls. 968 */ 969 static void 970 ieee80211_syncflag_vht_locked(struct ieee80211com *ic, int flag) 971 { 972 struct ieee80211vap *vap; 973 int bit; 974 975 IEEE80211_LOCK_ASSERT(ic); 976 977 bit = 0; 978 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 979 if (vap->iv_vht_flags & flag) { 980 bit = 1; 981 break; 982 } 983 if (bit) 984 ic->ic_vht_flags |= flag; 985 else 986 ic->ic_vht_flags &= ~flag; 987 } 988 989 void 990 ieee80211_syncflag_vht(struct ieee80211vap *vap, int flag) 991 { 992 struct ieee80211com *ic = vap->iv_ic; 993 994 IEEE80211_LOCK(ic); 995 if (flag < 0) { 996 flag = -flag; 997 vap->iv_vht_flags &= ~flag; 998 } else 999 vap->iv_vht_flags |= flag; 1000 ieee80211_syncflag_vht_locked(ic, flag); 1001 IEEE80211_UNLOCK(ic); 1002 } 1003 1004 /* 1005 * Synchronize flags_ext bit state in the com structure 1006 * according to the state of all vap's. This is used, 1007 * for example, to handle state changes via ioctls. 1008 */ 1009 static void 1010 ieee80211_syncflag_ext_locked(struct ieee80211com *ic, int flag) 1011 { 1012 struct ieee80211vap *vap; 1013 int bit; 1014 1015 IEEE80211_LOCK_ASSERT(ic); 1016 1017 bit = 0; 1018 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 1019 if (vap->iv_flags_ext & flag) { 1020 bit = 1; 1021 break; 1022 } 1023 if (bit) 1024 ic->ic_flags_ext |= flag; 1025 else 1026 ic->ic_flags_ext &= ~flag; 1027 } 1028 1029 void 1030 ieee80211_syncflag_ext(struct ieee80211vap *vap, int flag) 1031 { 1032 struct ieee80211com *ic = vap->iv_ic; 1033 1034 IEEE80211_LOCK(ic); 1035 if (flag < 0) { 1036 flag = -flag; 1037 vap->iv_flags_ext &= ~flag; 1038 } else 1039 vap->iv_flags_ext |= flag; 1040 ieee80211_syncflag_ext_locked(ic, flag); 1041 IEEE80211_UNLOCK(ic); 1042 } 1043 1044 static __inline int 1045 mapgsm(u_int freq, u_int flags) 1046 { 1047 freq *= 10; 1048 if (flags & IEEE80211_CHAN_QUARTER) 1049 freq += 5; 1050 else if (flags & IEEE80211_CHAN_HALF) 1051 freq += 10; 1052 else 1053 freq += 20; 1054 /* NB: there is no 907/20 wide but leave room */ 1055 return (freq - 906*10) / 5; 1056 } 1057 1058 static __inline int 1059 mappsb(u_int freq, u_int flags) 1060 { 1061 return 37 + ((freq * 10) + ((freq % 5) == 2 ? 5 : 0) - 49400) / 5; 1062 } 1063 1064 /* 1065 * Convert MHz frequency to IEEE channel number. 1066 */ 1067 int 1068 ieee80211_mhz2ieee(u_int freq, u_int flags) 1069 { 1070 #define IS_FREQ_IN_PSB(_freq) ((_freq) > 4940 && (_freq) < 4990) 1071 if (flags & IEEE80211_CHAN_GSM) 1072 return mapgsm(freq, flags); 1073 if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */ 1074 if (freq == 2484) 1075 return 14; 1076 if (freq < 2484) 1077 return ((int) freq - 2407) / 5; 1078 else 1079 return 15 + ((freq - 2512) / 20); 1080 } else if (flags & IEEE80211_CHAN_5GHZ) { /* 5Ghz band */ 1081 if (freq <= 5000) { 1082 /* XXX check regdomain? */ 1083 if (IS_FREQ_IN_PSB(freq)) 1084 return mappsb(freq, flags); 1085 return (freq - 4000) / 5; 1086 } else 1087 return (freq - 5000) / 5; 1088 } else { /* either, guess */ 1089 if (freq == 2484) 1090 return 14; 1091 if (freq < 2484) { 1092 if (907 <= freq && freq <= 922) 1093 return mapgsm(freq, flags); 1094 return ((int) freq - 2407) / 5; 1095 } 1096 if (freq < 5000) { 1097 if (IS_FREQ_IN_PSB(freq)) 1098 return mappsb(freq, flags); 1099 else if (freq > 4900) 1100 return (freq - 4000) / 5; 1101 else 1102 return 15 + ((freq - 2512) / 20); 1103 } 1104 return (freq - 5000) / 5; 1105 } 1106 #undef IS_FREQ_IN_PSB 1107 } 1108 1109 /* 1110 * Convert channel to IEEE channel number. 1111 */ 1112 int 1113 ieee80211_chan2ieee(struct ieee80211com *ic, const struct ieee80211_channel *c) 1114 { 1115 if (c == NULL) { 1116 ic_printf(ic, "invalid channel (NULL)\n"); 1117 return 0; /* XXX */ 1118 } 1119 return (c == IEEE80211_CHAN_ANYC ? IEEE80211_CHAN_ANY : c->ic_ieee); 1120 } 1121 1122 /* 1123 * Convert IEEE channel number to MHz frequency. 1124 */ 1125 u_int 1126 ieee80211_ieee2mhz(u_int chan, u_int flags) 1127 { 1128 if (flags & IEEE80211_CHAN_GSM) 1129 return 907 + 5 * (chan / 10); 1130 if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */ 1131 if (chan == 14) 1132 return 2484; 1133 if (chan < 14) 1134 return 2407 + chan*5; 1135 else 1136 return 2512 + ((chan-15)*20); 1137 } else if (flags & IEEE80211_CHAN_5GHZ) {/* 5Ghz band */ 1138 if (flags & (IEEE80211_CHAN_HALF|IEEE80211_CHAN_QUARTER)) { 1139 chan -= 37; 1140 return 4940 + chan*5 + (chan % 5 ? 2 : 0); 1141 } 1142 return 5000 + (chan*5); 1143 } else { /* either, guess */ 1144 /* XXX can't distinguish PSB+GSM channels */ 1145 if (chan == 14) 1146 return 2484; 1147 if (chan < 14) /* 0-13 */ 1148 return 2407 + chan*5; 1149 if (chan < 27) /* 15-26 */ 1150 return 2512 + ((chan-15)*20); 1151 return 5000 + (chan*5); 1152 } 1153 } 1154 1155 static __inline void 1156 set_extchan(struct ieee80211_channel *c) 1157 { 1158 1159 /* 1160 * IEEE Std 802.11-2012, page 1738, subclause 20.3.15.4: 1161 * "the secondary channel number shall be 'N + [1,-1] * 4' 1162 */ 1163 if (c->ic_flags & IEEE80211_CHAN_HT40U) 1164 c->ic_extieee = c->ic_ieee + 4; 1165 else if (c->ic_flags & IEEE80211_CHAN_HT40D) 1166 c->ic_extieee = c->ic_ieee - 4; 1167 else 1168 c->ic_extieee = 0; 1169 } 1170 1171 /* 1172 * Populate the freq1/freq2 fields as appropriate for VHT channels. 1173 * 1174 * This for now uses a hard-coded list of 80MHz wide channels. 1175 * 1176 * For HT20/HT40, freq1 just is the centre frequency of the 40MHz 1177 * wide channel we've already decided upon. 1178 * 1179 * For VHT80 and VHT160, there are only a small number of fixed 1180 * 80/160MHz wide channels, so we just use those. 1181 * 1182 * This is all likely very very wrong - both the regulatory code 1183 * and this code needs to ensure that all four channels are 1184 * available and valid before the VHT80 (and eight for VHT160) channel 1185 * is created. 1186 */ 1187 1188 struct vht_chan_range { 1189 uint16_t freq_start; 1190 uint16_t freq_end; 1191 }; 1192 1193 struct vht_chan_range vht80_chan_ranges[] = { 1194 { 5170, 5250 }, 1195 { 5250, 5330 }, 1196 { 5490, 5570 }, 1197 { 5570, 5650 }, 1198 { 5650, 5730 }, 1199 { 5735, 5815 }, 1200 { 5815, 5895 }, 1201 { 0, 0 } 1202 }; 1203 1204 struct vht_chan_range vht160_chan_ranges[] = { 1205 { 5170, 5330 }, 1206 { 5490, 5650 }, 1207 { 5735, 5895 }, 1208 { 0, 0 } 1209 }; 1210 1211 static int 1212 set_vht_extchan(struct ieee80211_channel *c) 1213 { 1214 int i; 1215 1216 if (! IEEE80211_IS_CHAN_VHT(c)) 1217 return (0); 1218 1219 if (IEEE80211_IS_CHAN_VHT80P80(c)) { 1220 printf("%s: TODO VHT80+80 channel (ieee=%d, flags=0x%08x)\n", 1221 __func__, c->ic_ieee, c->ic_flags); 1222 } 1223 1224 if (IEEE80211_IS_CHAN_VHT160(c)) { 1225 for (i = 0; vht160_chan_ranges[i].freq_start != 0; i++) { 1226 if (c->ic_freq >= vht160_chan_ranges[i].freq_start && 1227 c->ic_freq < vht160_chan_ranges[i].freq_end) { 1228 int midpoint; 1229 1230 midpoint = vht160_chan_ranges[i].freq_start + 80; 1231 c->ic_vht_ch_freq1 = 1232 ieee80211_mhz2ieee(midpoint, c->ic_flags); 1233 c->ic_vht_ch_freq2 = 0; 1234 #if 0 1235 printf("%s: %d, freq=%d, midpoint=%d, freq1=%d, freq2=%d\n", 1236 __func__, c->ic_ieee, c->ic_freq, midpoint, 1237 c->ic_vht_ch_freq1, c->ic_vht_ch_freq2); 1238 #endif 1239 return (1); 1240 } 1241 } 1242 return (0); 1243 } 1244 1245 if (IEEE80211_IS_CHAN_VHT80(c)) { 1246 for (i = 0; vht80_chan_ranges[i].freq_start != 0; i++) { 1247 if (c->ic_freq >= vht80_chan_ranges[i].freq_start && 1248 c->ic_freq < vht80_chan_ranges[i].freq_end) { 1249 int midpoint; 1250 1251 midpoint = vht80_chan_ranges[i].freq_start + 40; 1252 c->ic_vht_ch_freq1 = 1253 ieee80211_mhz2ieee(midpoint, c->ic_flags); 1254 c->ic_vht_ch_freq2 = 0; 1255 #if 0 1256 printf("%s: %d, freq=%d, midpoint=%d, freq1=%d, freq2=%d\n", 1257 __func__, c->ic_ieee, c->ic_freq, midpoint, 1258 c->ic_vht_ch_freq1, c->ic_vht_ch_freq2); 1259 #endif 1260 return (1); 1261 } 1262 } 1263 return (0); 1264 } 1265 1266 if (IEEE80211_IS_CHAN_VHT40(c)) { 1267 if (IEEE80211_IS_CHAN_HT40U(c)) 1268 c->ic_vht_ch_freq1 = c->ic_ieee + 2; 1269 else if (IEEE80211_IS_CHAN_HT40D(c)) 1270 c->ic_vht_ch_freq1 = c->ic_ieee - 2; 1271 else 1272 return (0); 1273 return (1); 1274 } 1275 1276 if (IEEE80211_IS_CHAN_VHT20(c)) { 1277 c->ic_vht_ch_freq1 = c->ic_ieee; 1278 return (1); 1279 } 1280 1281 printf("%s: unknown VHT channel type (ieee=%d, flags=0x%08x)\n", 1282 __func__, c->ic_ieee, c->ic_flags); 1283 1284 return (0); 1285 } 1286 1287 /* 1288 * Return whether the current channel could possibly be a part of 1289 * a VHT80/VHT160 channel. 1290 * 1291 * This doesn't check that the whole range is in the allowed list 1292 * according to regulatory. 1293 */ 1294 static bool 1295 is_vht160_valid_freq(uint16_t freq) 1296 { 1297 int i; 1298 1299 for (i = 0; vht160_chan_ranges[i].freq_start != 0; i++) { 1300 if (freq >= vht160_chan_ranges[i].freq_start && 1301 freq < vht160_chan_ranges[i].freq_end) 1302 return (true); 1303 } 1304 return (false); 1305 } 1306 1307 static int 1308 is_vht80_valid_freq(uint16_t freq) 1309 { 1310 int i; 1311 for (i = 0; vht80_chan_ranges[i].freq_start != 0; i++) { 1312 if (freq >= vht80_chan_ranges[i].freq_start && 1313 freq < vht80_chan_ranges[i].freq_end) 1314 return (1); 1315 } 1316 return (0); 1317 } 1318 1319 static int 1320 addchan(struct ieee80211_channel chans[], int maxchans, int *nchans, 1321 uint8_t ieee, uint16_t freq, int8_t maxregpower, uint32_t flags) 1322 { 1323 struct ieee80211_channel *c; 1324 1325 if (*nchans >= maxchans) 1326 return (ENOBUFS); 1327 1328 #if 0 1329 printf("%s: %d of %d: ieee=%d, freq=%d, flags=0x%08x\n", 1330 __func__, *nchans, maxchans, ieee, freq, flags); 1331 #endif 1332 1333 c = &chans[(*nchans)++]; 1334 c->ic_ieee = ieee; 1335 c->ic_freq = freq != 0 ? freq : ieee80211_ieee2mhz(ieee, flags); 1336 c->ic_maxregpower = maxregpower; 1337 c->ic_maxpower = 2 * maxregpower; 1338 c->ic_flags = flags; 1339 c->ic_vht_ch_freq1 = 0; 1340 c->ic_vht_ch_freq2 = 0; 1341 set_extchan(c); 1342 set_vht_extchan(c); 1343 1344 return (0); 1345 } 1346 1347 static int 1348 copychan_prev(struct ieee80211_channel chans[], int maxchans, int *nchans, 1349 uint32_t flags) 1350 { 1351 struct ieee80211_channel *c; 1352 1353 KASSERT(*nchans > 0, ("channel list is empty\n")); 1354 1355 if (*nchans >= maxchans) 1356 return (ENOBUFS); 1357 1358 #if 0 1359 printf("%s: %d of %d: flags=0x%08x\n", 1360 __func__, *nchans, maxchans, flags); 1361 #endif 1362 1363 c = &chans[(*nchans)++]; 1364 c[0] = c[-1]; 1365 c->ic_flags = flags; 1366 c->ic_vht_ch_freq1 = 0; 1367 c->ic_vht_ch_freq2 = 0; 1368 set_extchan(c); 1369 set_vht_extchan(c); 1370 1371 return (0); 1372 } 1373 1374 /* 1375 * XXX VHT-2GHz 1376 */ 1377 static void 1378 getflags_2ghz(const uint8_t bands[], uint32_t flags[], int cbw_flags) 1379 { 1380 int nmodes; 1381 1382 nmodes = 0; 1383 if (isset(bands, IEEE80211_MODE_11B)) 1384 flags[nmodes++] = IEEE80211_CHAN_B; 1385 if (isset(bands, IEEE80211_MODE_11G)) 1386 flags[nmodes++] = IEEE80211_CHAN_G; 1387 if (isset(bands, IEEE80211_MODE_11NG)) 1388 flags[nmodes++] = IEEE80211_CHAN_G | IEEE80211_CHAN_HT20; 1389 if (cbw_flags & NET80211_CBW_FLAG_HT40) { 1390 flags[nmodes++] = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40U; 1391 flags[nmodes++] = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40D; 1392 } 1393 flags[nmodes] = 0; 1394 } 1395 1396 static void 1397 getflags_5ghz(const uint8_t bands[], uint32_t flags[], int cbw_flags) 1398 { 1399 int nmodes; 1400 1401 /* 1402 * The addchan_list() function seems to expect the flags array to 1403 * be in channel width order, so the VHT bits are interspersed 1404 * as appropriate to maintain said order. 1405 * 1406 * It also assumes HT40U is before HT40D. 1407 */ 1408 nmodes = 0; 1409 1410 /* 20MHz */ 1411 if (isset(bands, IEEE80211_MODE_11A)) 1412 flags[nmodes++] = IEEE80211_CHAN_A; 1413 if (isset(bands, IEEE80211_MODE_11NA)) 1414 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20; 1415 if (isset(bands, IEEE80211_MODE_VHT_5GHZ)) { 1416 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20 | 1417 IEEE80211_CHAN_VHT20; 1418 } 1419 1420 /* 40MHz */ 1421 if (cbw_flags & NET80211_CBW_FLAG_HT40) 1422 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U; 1423 if ((cbw_flags & NET80211_CBW_FLAG_HT40) && 1424 isset(bands, IEEE80211_MODE_VHT_5GHZ)) 1425 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U | 1426 IEEE80211_CHAN_VHT40U; 1427 if (cbw_flags & NET80211_CBW_FLAG_HT40) 1428 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D; 1429 if ((cbw_flags & NET80211_CBW_FLAG_HT40) && 1430 isset(bands, IEEE80211_MODE_VHT_5GHZ)) 1431 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D | 1432 IEEE80211_CHAN_VHT40D; 1433 1434 /* 80MHz */ 1435 if ((cbw_flags & NET80211_CBW_FLAG_VHT80) && 1436 isset(bands, IEEE80211_MODE_VHT_5GHZ)) { 1437 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U | 1438 IEEE80211_CHAN_VHT80; 1439 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D | 1440 IEEE80211_CHAN_VHT80; 1441 } 1442 1443 /* VHT160 */ 1444 if ((cbw_flags & NET80211_CBW_FLAG_VHT160) && 1445 isset(bands, IEEE80211_MODE_VHT_5GHZ)) { 1446 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U | 1447 IEEE80211_CHAN_VHT160; 1448 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D | 1449 IEEE80211_CHAN_VHT160; 1450 } 1451 1452 /* VHT80+80 */ 1453 if ((cbw_flags & NET80211_CBW_FLAG_VHT80P80) && 1454 isset(bands, IEEE80211_MODE_VHT_5GHZ)) { 1455 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40U | 1456 IEEE80211_CHAN_VHT80P80; 1457 flags[nmodes++] = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40D | 1458 IEEE80211_CHAN_VHT80P80; 1459 } 1460 1461 flags[nmodes] = 0; 1462 } 1463 1464 static void 1465 getflags(const uint8_t bands[], uint32_t flags[], int cbw_flags) 1466 { 1467 1468 flags[0] = 0; 1469 if (isset(bands, IEEE80211_MODE_11A) || 1470 isset(bands, IEEE80211_MODE_11NA) || 1471 isset(bands, IEEE80211_MODE_VHT_5GHZ)) { 1472 if (isset(bands, IEEE80211_MODE_11B) || 1473 isset(bands, IEEE80211_MODE_11G) || 1474 isset(bands, IEEE80211_MODE_11NG) || 1475 isset(bands, IEEE80211_MODE_VHT_2GHZ)) 1476 return; 1477 1478 getflags_5ghz(bands, flags, cbw_flags); 1479 } else 1480 getflags_2ghz(bands, flags, cbw_flags); 1481 } 1482 1483 /* 1484 * Add one 20 MHz channel into specified channel list. 1485 * You MUST NOT mix bands when calling this. It will not add 5ghz 1486 * channels if you have any B/G/N band bit set. 1487 * The _cbw() variant does also support HT40/VHT80/160/80+80. 1488 */ 1489 int 1490 ieee80211_add_channel_cbw(struct ieee80211_channel chans[], int maxchans, 1491 int *nchans, uint8_t ieee, uint16_t freq, int8_t maxregpower, 1492 uint32_t chan_flags, const uint8_t bands[], int cbw_flags) 1493 { 1494 uint32_t flags[IEEE80211_MODE_MAX]; 1495 int i, error; 1496 1497 getflags(bands, flags, cbw_flags); 1498 KASSERT(flags[0] != 0, ("%s: no correct mode provided\n", __func__)); 1499 1500 error = addchan(chans, maxchans, nchans, ieee, freq, maxregpower, 1501 flags[0] | chan_flags); 1502 for (i = 1; flags[i] != 0 && error == 0; i++) { 1503 error = copychan_prev(chans, maxchans, nchans, 1504 flags[i] | chan_flags); 1505 } 1506 1507 return (error); 1508 } 1509 1510 int 1511 ieee80211_add_channel(struct ieee80211_channel chans[], int maxchans, 1512 int *nchans, uint8_t ieee, uint16_t freq, int8_t maxregpower, 1513 uint32_t chan_flags, const uint8_t bands[]) 1514 { 1515 1516 return (ieee80211_add_channel_cbw(chans, maxchans, nchans, ieee, freq, 1517 maxregpower, chan_flags, bands, 0)); 1518 } 1519 1520 static struct ieee80211_channel * 1521 findchannel(struct ieee80211_channel chans[], int nchans, uint16_t freq, 1522 uint32_t flags) 1523 { 1524 struct ieee80211_channel *c; 1525 int i; 1526 1527 flags &= IEEE80211_CHAN_ALLTURBO; 1528 /* brute force search */ 1529 for (i = 0; i < nchans; i++) { 1530 c = &chans[i]; 1531 if (c->ic_freq == freq && 1532 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 1533 return c; 1534 } 1535 return NULL; 1536 } 1537 1538 /* 1539 * Add 40 MHz channel pair into specified channel list. 1540 */ 1541 /* XXX VHT */ 1542 int 1543 ieee80211_add_channel_ht40(struct ieee80211_channel chans[], int maxchans, 1544 int *nchans, uint8_t ieee, int8_t maxregpower, uint32_t flags) 1545 { 1546 struct ieee80211_channel *cent, *extc; 1547 uint16_t freq; 1548 int error; 1549 1550 freq = ieee80211_ieee2mhz(ieee, flags); 1551 1552 /* 1553 * Each entry defines an HT40 channel pair; find the 1554 * center channel, then the extension channel above. 1555 */ 1556 flags |= IEEE80211_CHAN_HT20; 1557 cent = findchannel(chans, *nchans, freq, flags); 1558 if (cent == NULL) 1559 return (EINVAL); 1560 1561 extc = findchannel(chans, *nchans, freq + 20, flags); 1562 if (extc == NULL) 1563 return (ENOENT); 1564 1565 flags &= ~IEEE80211_CHAN_HT; 1566 error = addchan(chans, maxchans, nchans, cent->ic_ieee, cent->ic_freq, 1567 maxregpower, flags | IEEE80211_CHAN_HT40U); 1568 if (error != 0) 1569 return (error); 1570 1571 error = addchan(chans, maxchans, nchans, extc->ic_ieee, extc->ic_freq, 1572 maxregpower, flags | IEEE80211_CHAN_HT40D); 1573 1574 return (error); 1575 } 1576 1577 /* 1578 * Fetch the center frequency for the primary channel. 1579 */ 1580 uint32_t 1581 ieee80211_get_channel_center_freq(const struct ieee80211_channel *c) 1582 { 1583 1584 return (c->ic_freq); 1585 } 1586 1587 /* 1588 * Fetch the center frequency for the primary BAND channel. 1589 * 1590 * For 5, 10, 20MHz channels it'll be the normally configured channel 1591 * frequency. 1592 * 1593 * For 40MHz, 80MHz, 160MHz channels it will be the centre of the 1594 * wide channel, not the centre of the primary channel (that's ic_freq). 1595 * 1596 * For 80+80MHz channels this will be the centre of the primary 1597 * 80MHz channel; the secondary 80MHz channel will be center_freq2(). 1598 */ 1599 uint32_t 1600 ieee80211_get_channel_center_freq1(const struct ieee80211_channel *c) 1601 { 1602 1603 /* 1604 * VHT - use the pre-calculated centre frequency 1605 * of the given channel. 1606 */ 1607 if (IEEE80211_IS_CHAN_VHT(c)) 1608 return (ieee80211_ieee2mhz(c->ic_vht_ch_freq1, c->ic_flags)); 1609 1610 if (IEEE80211_IS_CHAN_HT40U(c)) { 1611 return (c->ic_freq + 10); 1612 } 1613 if (IEEE80211_IS_CHAN_HT40D(c)) { 1614 return (c->ic_freq - 10); 1615 } 1616 1617 return (c->ic_freq); 1618 } 1619 1620 /* 1621 * For now, no 80+80 support; it will likely always return 0. 1622 */ 1623 uint32_t 1624 ieee80211_get_channel_center_freq2(const struct ieee80211_channel *c) 1625 { 1626 1627 if (IEEE80211_IS_CHAN_VHT(c) && (c->ic_vht_ch_freq2 != 0)) 1628 return (ieee80211_ieee2mhz(c->ic_vht_ch_freq2, c->ic_flags)); 1629 1630 return (0); 1631 } 1632 1633 /* 1634 * Adds channels into specified channel list (ieee[] array must be sorted). 1635 * Channels are already sorted. 1636 */ 1637 static int 1638 add_chanlist(struct ieee80211_channel chans[], int maxchans, int *nchans, 1639 const uint8_t ieee[], int nieee, uint32_t flags[]) 1640 { 1641 uint16_t freq; 1642 int i, j, error; 1643 int is_vht; 1644 1645 for (i = 0; i < nieee; i++) { 1646 freq = ieee80211_ieee2mhz(ieee[i], flags[0]); 1647 for (j = 0; flags[j] != 0; j++) { 1648 /* 1649 * Notes: 1650 * + HT40 and VHT40 channels occur together, so 1651 * we need to be careful that we actually allow that. 1652 * + VHT80, VHT160 will coexist with HT40/VHT40, so 1653 * make sure it's not skipped because of the overlap 1654 * check used for (V)HT40. 1655 */ 1656 is_vht = !! (flags[j] & IEEE80211_CHAN_VHT); 1657 1658 /* XXX TODO FIXME VHT80P80. */ 1659 1660 /* Test for VHT160 analogue to the VHT80 below. */ 1661 if (is_vht && flags[j] & IEEE80211_CHAN_VHT160) 1662 if (! is_vht160_valid_freq(freq)) 1663 continue; 1664 1665 /* 1666 * Test for VHT80. 1667 * XXX This is all very broken right now. 1668 * What we /should/ do is: 1669 * 1670 * + check that the frequency is in the list of 1671 * allowed VHT80 ranges; and 1672 * + the other 3 channels in the list are actually 1673 * also available. 1674 */ 1675 if (is_vht && flags[j] & IEEE80211_CHAN_VHT80) 1676 if (! is_vht80_valid_freq(freq)) 1677 continue; 1678 1679 /* 1680 * Test for (V)HT40. 1681 * 1682 * This is also a fall through from VHT80; as we only 1683 * allow a VHT80 channel if the VHT40 combination is 1684 * also valid. If the VHT40 form is not valid then 1685 * we certainly can't do VHT80.. 1686 */ 1687 if (flags[j] & IEEE80211_CHAN_HT40D) 1688 /* 1689 * Can't have a "lower" channel if we are the 1690 * first channel. 1691 * 1692 * Can't have a "lower" channel if it's below/ 1693 * within 20MHz of the first channel. 1694 * 1695 * Can't have a "lower" channel if the channel 1696 * below it is not 20MHz away. 1697 */ 1698 if (i == 0 || ieee[i] < ieee[0] + 4 || 1699 freq - 20 != 1700 ieee80211_ieee2mhz(ieee[i] - 4, flags[j])) 1701 continue; 1702 if (flags[j] & IEEE80211_CHAN_HT40U) 1703 /* 1704 * Can't have an "upper" channel if we are 1705 * the last channel. 1706 * 1707 * Can't have an "upper" channel be above the 1708 * last channel in the list. 1709 * 1710 * Can't have an "upper" channel if the next 1711 * channel according to the math isn't 20MHz 1712 * away. (Likely for channel 13/14.) 1713 */ 1714 if (i == nieee - 1 || 1715 ieee[i] + 4 > ieee[nieee - 1] || 1716 freq + 20 != 1717 ieee80211_ieee2mhz(ieee[i] + 4, flags[j])) 1718 continue; 1719 1720 if (j == 0) { 1721 error = addchan(chans, maxchans, nchans, 1722 ieee[i], freq, 0, flags[j]); 1723 } else { 1724 error = copychan_prev(chans, maxchans, nchans, 1725 flags[j]); 1726 } 1727 if (error != 0) 1728 return (error); 1729 } 1730 } 1731 1732 return (0); 1733 } 1734 1735 int 1736 ieee80211_add_channel_list_2ghz(struct ieee80211_channel chans[], int maxchans, 1737 int *nchans, const uint8_t ieee[], int nieee, const uint8_t bands[], 1738 int cbw_flags) 1739 { 1740 uint32_t flags[IEEE80211_MODE_MAX]; 1741 1742 /* XXX no VHT for now */ 1743 getflags_2ghz(bands, flags, cbw_flags); 1744 KASSERT(flags[0] != 0, ("%s: no correct mode provided\n", __func__)); 1745 1746 return (add_chanlist(chans, maxchans, nchans, ieee, nieee, flags)); 1747 } 1748 1749 int 1750 ieee80211_add_channels_default_2ghz(struct ieee80211_channel chans[], 1751 int maxchans, int *nchans, const uint8_t bands[], int cbw_flags) 1752 { 1753 const uint8_t default_chan_list[] = 1754 { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }; 1755 1756 return (ieee80211_add_channel_list_2ghz(chans, maxchans, nchans, 1757 default_chan_list, nitems(default_chan_list), bands, cbw_flags)); 1758 } 1759 1760 int 1761 ieee80211_add_channel_list_5ghz(struct ieee80211_channel chans[], int maxchans, 1762 int *nchans, const uint8_t ieee[], int nieee, const uint8_t bands[], 1763 int cbw_flags) 1764 { 1765 /* 1766 * XXX-BZ with HT and VHT there is no 1:1 mapping anymore. Review all 1767 * uses of IEEE80211_MODE_MAX and add a new #define name for array size. 1768 */ 1769 uint32_t flags[2 * IEEE80211_MODE_MAX]; 1770 1771 getflags_5ghz(bands, flags, cbw_flags); 1772 KASSERT(flags[0] != 0, ("%s: no correct mode provided\n", __func__)); 1773 1774 return (add_chanlist(chans, maxchans, nchans, ieee, nieee, flags)); 1775 } 1776 1777 /* 1778 * Locate a channel given a frequency+flags. We cache 1779 * the previous lookup to optimize switching between two 1780 * channels--as happens with dynamic turbo. 1781 */ 1782 struct ieee80211_channel * 1783 ieee80211_find_channel(struct ieee80211com *ic, int freq, int flags) 1784 { 1785 struct ieee80211_channel *c; 1786 1787 flags &= IEEE80211_CHAN_ALLTURBO; 1788 c = ic->ic_prevchan; 1789 if (c != NULL && c->ic_freq == freq && 1790 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 1791 return c; 1792 /* brute force search */ 1793 return (findchannel(ic->ic_channels, ic->ic_nchans, freq, flags)); 1794 } 1795 1796 /* 1797 * Locate a channel given a channel number+flags. We cache 1798 * the previous lookup to optimize switching between two 1799 * channels--as happens with dynamic turbo. 1800 */ 1801 struct ieee80211_channel * 1802 ieee80211_find_channel_byieee(struct ieee80211com *ic, int ieee, int flags) 1803 { 1804 struct ieee80211_channel *c; 1805 int i; 1806 1807 flags &= IEEE80211_CHAN_ALLTURBO; 1808 c = ic->ic_prevchan; 1809 if (c != NULL && c->ic_ieee == ieee && 1810 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 1811 return c; 1812 /* brute force search */ 1813 for (i = 0; i < ic->ic_nchans; i++) { 1814 c = &ic->ic_channels[i]; 1815 if (c->ic_ieee == ieee && 1816 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 1817 return c; 1818 } 1819 return NULL; 1820 } 1821 1822 /* 1823 * Lookup a channel suitable for the given rx status. 1824 * 1825 * This is used to find a channel for a frame (eg beacon, probe 1826 * response) based purely on the received PHY information. 1827 * 1828 * For now it tries to do it based on R_FREQ / R_IEEE. 1829 * This is enough for 11bg and 11a (and thus 11ng/11na) 1830 * but it will not be enough for GSM, PSB channels and the 1831 * like. It also doesn't know about legacy-turbog and 1832 * legacy-turbo modes, which some offload NICs actually 1833 * support in weird ways. 1834 * 1835 * Takes the ic and rxstatus; returns the channel or NULL 1836 * if not found. 1837 * 1838 * XXX TODO: Add support for that when the need arises. 1839 */ 1840 struct ieee80211_channel * 1841 ieee80211_lookup_channel_rxstatus(struct ieee80211vap *vap, 1842 const struct ieee80211_rx_stats *rxs) 1843 { 1844 struct ieee80211com *ic = vap->iv_ic; 1845 uint32_t flags; 1846 struct ieee80211_channel *c; 1847 1848 if (rxs == NULL) 1849 return (NULL); 1850 1851 /* 1852 * Strictly speaking we only use freq for now, 1853 * however later on we may wish to just store 1854 * the ieee for verification. 1855 */ 1856 if ((rxs->r_flags & IEEE80211_R_FREQ) == 0) 1857 return (NULL); 1858 if ((rxs->r_flags & IEEE80211_R_IEEE) == 0) 1859 return (NULL); 1860 if ((rxs->r_flags & IEEE80211_R_BAND) == 0) 1861 return (NULL); 1862 1863 /* 1864 * If the rx status contains a valid ieee/freq, then 1865 * ensure we populate the correct channel information 1866 * in rxchan before passing it up to the scan infrastructure. 1867 * Offload NICs will pass up beacons from all channels 1868 * during background scans. 1869 */ 1870 1871 /* Determine a band */ 1872 switch (rxs->c_band) { 1873 case IEEE80211_CHAN_2GHZ: 1874 flags = IEEE80211_CHAN_G; 1875 break; 1876 case IEEE80211_CHAN_5GHZ: 1877 flags = IEEE80211_CHAN_A; 1878 break; 1879 default: 1880 if (rxs->c_freq < 3000) { 1881 flags = IEEE80211_CHAN_G; 1882 } else { 1883 flags = IEEE80211_CHAN_A; 1884 } 1885 break; 1886 } 1887 1888 /* Channel lookup */ 1889 c = ieee80211_find_channel(ic, rxs->c_freq, flags); 1890 1891 IEEE80211_DPRINTF(vap, IEEE80211_MSG_INPUT, 1892 "%s: freq=%d, ieee=%d, flags=0x%08x; c=%p\n", 1893 __func__, (int) rxs->c_freq, (int) rxs->c_ieee, flags, c); 1894 1895 return (c); 1896 } 1897 1898 static void 1899 addmedia(struct ifmedia *media, int caps, int addsta, int mode, int mword) 1900 { 1901 #define ADD(_ic, _s, _o) \ 1902 ifmedia_add(media, \ 1903 IFM_MAKEWORD(IFM_IEEE80211, (_s), (_o), 0), 0, NULL) 1904 static const u_int mopts[IEEE80211_MODE_MAX] = { 1905 [IEEE80211_MODE_AUTO] = IFM_AUTO, 1906 [IEEE80211_MODE_11A] = IFM_IEEE80211_11A, 1907 [IEEE80211_MODE_11B] = IFM_IEEE80211_11B, 1908 [IEEE80211_MODE_11G] = IFM_IEEE80211_11G, 1909 [IEEE80211_MODE_FH] = IFM_IEEE80211_FH, 1910 [IEEE80211_MODE_TURBO_A] = IFM_IEEE80211_11A|IFM_IEEE80211_TURBO, 1911 [IEEE80211_MODE_TURBO_G] = IFM_IEEE80211_11G|IFM_IEEE80211_TURBO, 1912 [IEEE80211_MODE_STURBO_A] = IFM_IEEE80211_11A|IFM_IEEE80211_TURBO, 1913 [IEEE80211_MODE_HALF] = IFM_IEEE80211_11A, /* XXX */ 1914 [IEEE80211_MODE_QUARTER] = IFM_IEEE80211_11A, /* XXX */ 1915 [IEEE80211_MODE_11NA] = IFM_IEEE80211_11NA, 1916 [IEEE80211_MODE_11NG] = IFM_IEEE80211_11NG, 1917 [IEEE80211_MODE_VHT_2GHZ] = IFM_IEEE80211_VHT2G, 1918 [IEEE80211_MODE_VHT_5GHZ] = IFM_IEEE80211_VHT5G, 1919 }; 1920 u_int mopt; 1921 1922 mopt = mopts[mode]; 1923 if (addsta) 1924 ADD(ic, mword, mopt); /* STA mode has no cap */ 1925 if (caps & IEEE80211_C_IBSS) 1926 ADD(media, mword, mopt | IFM_IEEE80211_ADHOC); 1927 if (caps & IEEE80211_C_HOSTAP) 1928 ADD(media, mword, mopt | IFM_IEEE80211_HOSTAP); 1929 if (caps & IEEE80211_C_AHDEMO) 1930 ADD(media, mword, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0); 1931 if (caps & IEEE80211_C_MONITOR) 1932 ADD(media, mword, mopt | IFM_IEEE80211_MONITOR); 1933 if (caps & IEEE80211_C_WDS) 1934 ADD(media, mword, mopt | IFM_IEEE80211_WDS); 1935 if (caps & IEEE80211_C_MBSS) 1936 ADD(media, mword, mopt | IFM_IEEE80211_MBSS); 1937 #undef ADD 1938 } 1939 1940 /* 1941 * Setup the media data structures according to the channel and 1942 * rate tables. 1943 */ 1944 static int 1945 ieee80211_media_setup(struct ieee80211com *ic, 1946 struct ifmedia *media, int caps, int addsta, 1947 ifm_change_cb_t media_change, ifm_stat_cb_t media_stat) 1948 { 1949 int i, j, rate, maxrate, mword, r; 1950 enum ieee80211_phymode mode; 1951 const struct ieee80211_rateset *rs; 1952 struct ieee80211_rateset allrates; 1953 struct ieee80211_node_txrate tn; 1954 1955 /* 1956 * Fill in media characteristics. 1957 */ 1958 ifmedia_init(media, 0, media_change, media_stat); 1959 maxrate = 0; 1960 /* 1961 * Add media for legacy operating modes. 1962 */ 1963 memset(&allrates, 0, sizeof(allrates)); 1964 for (mode = IEEE80211_MODE_AUTO; mode < IEEE80211_MODE_11NA; mode++) { 1965 if (isclr(ic->ic_modecaps, mode)) 1966 continue; 1967 addmedia(media, caps, addsta, mode, IFM_AUTO); 1968 if (mode == IEEE80211_MODE_AUTO) 1969 continue; 1970 rs = &ic->ic_sup_rates[mode]; 1971 for (i = 0; i < rs->rs_nrates; i++) { 1972 rate = rs->rs_rates[i]; 1973 tn = IEEE80211_NODE_TXRATE_INIT_LEGACY(rate); 1974 mword = ieee80211_rate2media(ic, &tn, mode); 1975 if (mword == 0) 1976 continue; 1977 addmedia(media, caps, addsta, mode, mword); 1978 /* 1979 * Add legacy rate to the collection of all rates. 1980 */ 1981 r = rate & IEEE80211_RATE_VAL; 1982 for (j = 0; j < allrates.rs_nrates; j++) 1983 if (allrates.rs_rates[j] == r) 1984 break; 1985 if (j == allrates.rs_nrates) { 1986 /* unique, add to the set */ 1987 allrates.rs_rates[j] = r; 1988 allrates.rs_nrates++; 1989 } 1990 rate = (rate & IEEE80211_RATE_VAL) / 2; 1991 if (rate > maxrate) 1992 maxrate = rate; 1993 } 1994 } 1995 for (i = 0; i < allrates.rs_nrates; i++) { 1996 tn = IEEE80211_NODE_TXRATE_INIT_LEGACY(allrates.rs_rates[i]); 1997 mword = ieee80211_rate2media(ic, &tn, IEEE80211_MODE_AUTO); 1998 if (mword == 0) 1999 continue; 2000 /* NB: remove media options from mword */ 2001 addmedia(media, caps, addsta, 2002 IEEE80211_MODE_AUTO, IFM_SUBTYPE(mword)); 2003 } 2004 /* 2005 * Add HT/11n media. Note that we do not have enough 2006 * bits in the media subtype to express the MCS so we 2007 * use a "placeholder" media subtype and any fixed MCS 2008 * must be specified with a different mechanism. 2009 */ 2010 for (; mode <= IEEE80211_MODE_11NG; mode++) { 2011 if (isclr(ic->ic_modecaps, mode)) 2012 continue; 2013 addmedia(media, caps, addsta, mode, IFM_AUTO); 2014 addmedia(media, caps, addsta, mode, IFM_IEEE80211_MCS); 2015 } 2016 if (isset(ic->ic_modecaps, IEEE80211_MODE_11NA) || 2017 isset(ic->ic_modecaps, IEEE80211_MODE_11NG)) { 2018 addmedia(media, caps, addsta, 2019 IEEE80211_MODE_AUTO, IFM_IEEE80211_MCS); 2020 i = ic->ic_txstream * 8 - 1; 2021 if ((ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40) && 2022 (ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI40)) 2023 rate = ieee80211_htrates[i].ht40_rate_400ns; 2024 else if ((ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40)) 2025 rate = ieee80211_htrates[i].ht40_rate_800ns; 2026 else if ((ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI20)) 2027 rate = ieee80211_htrates[i].ht20_rate_400ns; 2028 else 2029 rate = ieee80211_htrates[i].ht20_rate_800ns; 2030 if (rate > maxrate) 2031 maxrate = rate; 2032 } 2033 2034 /* 2035 * Add VHT media. 2036 * XXX-BZ skip "VHT_2GHZ" for now. 2037 */ 2038 for (mode = IEEE80211_MODE_VHT_5GHZ; mode <= IEEE80211_MODE_VHT_5GHZ; 2039 mode++) { 2040 if (isclr(ic->ic_modecaps, mode)) 2041 continue; 2042 addmedia(media, caps, addsta, mode, IFM_AUTO); 2043 addmedia(media, caps, addsta, mode, IFM_IEEE80211_VHT); 2044 } 2045 if (isset(ic->ic_modecaps, IEEE80211_MODE_VHT_5GHZ)) { 2046 addmedia(media, caps, addsta, 2047 IEEE80211_MODE_AUTO, IFM_IEEE80211_VHT); 2048 2049 /* XXX TODO: VHT maxrate */ 2050 } 2051 2052 return maxrate; 2053 } 2054 2055 /* XXX inline or eliminate? */ 2056 const struct ieee80211_rateset * 2057 ieee80211_get_suprates(struct ieee80211com *ic, const struct ieee80211_channel *c) 2058 { 2059 /* XXX does this work for 11ng basic rates? */ 2060 return &ic->ic_sup_rates[ieee80211_chan2mode(c)]; 2061 } 2062 2063 /* XXX inline or eliminate? */ 2064 const struct ieee80211_htrateset * 2065 ieee80211_get_suphtrates(struct ieee80211com *ic, 2066 const struct ieee80211_channel *c) 2067 { 2068 return &ic->ic_sup_htrates; 2069 } 2070 2071 void 2072 ieee80211_announce(struct ieee80211com *ic) 2073 { 2074 int i, rate, mword; 2075 enum ieee80211_phymode mode; 2076 const struct ieee80211_rateset *rs; 2077 struct ieee80211_node_txrate tn; 2078 2079 /* NB: skip AUTO since it has no rates */ 2080 for (mode = IEEE80211_MODE_AUTO+1; mode < IEEE80211_MODE_11NA; mode++) { 2081 if (isclr(ic->ic_modecaps, mode)) 2082 continue; 2083 ic_printf(ic, "%s rates: ", ieee80211_phymode_name[mode]); 2084 rs = &ic->ic_sup_rates[mode]; 2085 for (i = 0; i < rs->rs_nrates; i++) { 2086 tn = IEEE80211_NODE_TXRATE_INIT_LEGACY(rs->rs_rates[i]); 2087 mword = ieee80211_rate2media(ic, &tn, mode); 2088 if (mword == 0) 2089 continue; 2090 rate = ieee80211_media2rate(mword); 2091 printf("%s%d%sMbps", (i != 0 ? " " : ""), 2092 rate / 2, ((rate & 0x1) != 0 ? ".5" : "")); 2093 } 2094 printf("\n"); 2095 } 2096 ieee80211_ht_announce(ic); 2097 ieee80211_vht_announce(ic); 2098 } 2099 2100 void 2101 ieee80211_announce_channels(struct ieee80211com *ic) 2102 { 2103 const struct ieee80211_channel *c; 2104 char type; 2105 int i, cw; 2106 2107 printf("Chan Freq CW RegPwr MinPwr MaxPwr\n"); 2108 for (i = 0; i < ic->ic_nchans; i++) { 2109 c = &ic->ic_channels[i]; 2110 if (IEEE80211_IS_CHAN_ST(c)) 2111 type = 'S'; 2112 else if (IEEE80211_IS_CHAN_108A(c)) 2113 type = 'T'; 2114 else if (IEEE80211_IS_CHAN_108G(c)) 2115 type = 'G'; 2116 else if (IEEE80211_IS_CHAN_HT(c)) 2117 type = 'n'; 2118 else if (IEEE80211_IS_CHAN_A(c)) 2119 type = 'a'; 2120 else if (IEEE80211_IS_CHAN_ANYG(c)) 2121 type = 'g'; 2122 else if (IEEE80211_IS_CHAN_B(c)) 2123 type = 'b'; 2124 else 2125 type = 'f'; 2126 if (IEEE80211_IS_CHAN_HT40(c) || IEEE80211_IS_CHAN_TURBO(c)) 2127 cw = 40; 2128 else if (IEEE80211_IS_CHAN_HALF(c)) 2129 cw = 10; 2130 else if (IEEE80211_IS_CHAN_QUARTER(c)) 2131 cw = 5; 2132 else 2133 cw = 20; 2134 printf("%4d %4d%c %2d%c %6d %4d.%d %4d.%d\n" 2135 , c->ic_ieee, c->ic_freq, type 2136 , cw 2137 , IEEE80211_IS_CHAN_HT40U(c) ? '+' : 2138 IEEE80211_IS_CHAN_HT40D(c) ? '-' : ' ' 2139 , c->ic_maxregpower 2140 , c->ic_minpower / 2, c->ic_minpower & 1 ? 5 : 0 2141 , c->ic_maxpower / 2, c->ic_maxpower & 1 ? 5 : 0 2142 ); 2143 } 2144 } 2145 2146 static int 2147 media2mode(const struct ifmedia_entry *ime, uint32_t flags, uint16_t *mode) 2148 { 2149 switch (IFM_MODE(ime->ifm_media)) { 2150 case IFM_IEEE80211_11A: 2151 *mode = IEEE80211_MODE_11A; 2152 break; 2153 case IFM_IEEE80211_11B: 2154 *mode = IEEE80211_MODE_11B; 2155 break; 2156 case IFM_IEEE80211_11G: 2157 *mode = IEEE80211_MODE_11G; 2158 break; 2159 case IFM_IEEE80211_FH: 2160 *mode = IEEE80211_MODE_FH; 2161 break; 2162 case IFM_IEEE80211_11NA: 2163 *mode = IEEE80211_MODE_11NA; 2164 break; 2165 case IFM_IEEE80211_11NG: 2166 *mode = IEEE80211_MODE_11NG; 2167 break; 2168 case IFM_IEEE80211_VHT2G: 2169 *mode = IEEE80211_MODE_VHT_2GHZ; 2170 break; 2171 case IFM_IEEE80211_VHT5G: 2172 *mode = IEEE80211_MODE_VHT_5GHZ; 2173 break; 2174 case IFM_AUTO: 2175 *mode = IEEE80211_MODE_AUTO; 2176 break; 2177 default: 2178 return 0; 2179 } 2180 /* 2181 * Turbo mode is an ``option''. 2182 * XXX does not apply to AUTO 2183 */ 2184 if (ime->ifm_media & IFM_IEEE80211_TURBO) { 2185 if (*mode == IEEE80211_MODE_11A) { 2186 if (flags & IEEE80211_F_TURBOP) 2187 *mode = IEEE80211_MODE_TURBO_A; 2188 else 2189 *mode = IEEE80211_MODE_STURBO_A; 2190 } else if (*mode == IEEE80211_MODE_11G) 2191 *mode = IEEE80211_MODE_TURBO_G; 2192 else 2193 return 0; 2194 } 2195 /* XXX HT40 +/- */ 2196 return 1; 2197 } 2198 2199 /* 2200 * Handle a media change request on the vap interface. 2201 */ 2202 int 2203 ieee80211_media_change(struct ifnet *ifp) 2204 { 2205 struct ieee80211vap *vap = ifp->if_softc; 2206 struct ifmedia_entry *ime = vap->iv_media.ifm_cur; 2207 uint16_t newmode; 2208 2209 if (!media2mode(ime, vap->iv_flags, &newmode)) 2210 return EINVAL; 2211 if (vap->iv_des_mode != newmode) { 2212 vap->iv_des_mode = newmode; 2213 /* XXX kick state machine if up+running */ 2214 } 2215 return 0; 2216 } 2217 2218 /* 2219 * Common code to calculate the media status word 2220 * from the operating mode and channel state. 2221 */ 2222 static int 2223 media_status(enum ieee80211_opmode opmode, const struct ieee80211_channel *chan) 2224 { 2225 int status; 2226 2227 status = IFM_IEEE80211; 2228 switch (opmode) { 2229 case IEEE80211_M_STA: 2230 break; 2231 case IEEE80211_M_IBSS: 2232 status |= IFM_IEEE80211_ADHOC; 2233 break; 2234 case IEEE80211_M_HOSTAP: 2235 status |= IFM_IEEE80211_HOSTAP; 2236 break; 2237 case IEEE80211_M_MONITOR: 2238 status |= IFM_IEEE80211_MONITOR; 2239 break; 2240 case IEEE80211_M_AHDEMO: 2241 status |= IFM_IEEE80211_ADHOC | IFM_FLAG0; 2242 break; 2243 case IEEE80211_M_WDS: 2244 status |= IFM_IEEE80211_WDS; 2245 break; 2246 case IEEE80211_M_MBSS: 2247 status |= IFM_IEEE80211_MBSS; 2248 break; 2249 } 2250 if (IEEE80211_IS_CHAN_VHT_5GHZ(chan)) { 2251 status |= IFM_IEEE80211_VHT5G; 2252 } else if (IEEE80211_IS_CHAN_VHT_2GHZ(chan)) { 2253 status |= IFM_IEEE80211_VHT2G; 2254 } else if (IEEE80211_IS_CHAN_HTA(chan)) { 2255 status |= IFM_IEEE80211_11NA; 2256 } else if (IEEE80211_IS_CHAN_HTG(chan)) { 2257 status |= IFM_IEEE80211_11NG; 2258 } else if (IEEE80211_IS_CHAN_A(chan)) { 2259 status |= IFM_IEEE80211_11A; 2260 } else if (IEEE80211_IS_CHAN_B(chan)) { 2261 status |= IFM_IEEE80211_11B; 2262 } else if (IEEE80211_IS_CHAN_ANYG(chan)) { 2263 status |= IFM_IEEE80211_11G; 2264 } else if (IEEE80211_IS_CHAN_FHSS(chan)) { 2265 status |= IFM_IEEE80211_FH; 2266 } 2267 /* XXX else complain? */ 2268 2269 if (IEEE80211_IS_CHAN_TURBO(chan)) 2270 status |= IFM_IEEE80211_TURBO; 2271 #if 0 2272 if (IEEE80211_IS_CHAN_HT20(chan)) 2273 status |= IFM_IEEE80211_HT20; 2274 if (IEEE80211_IS_CHAN_HT40(chan)) 2275 status |= IFM_IEEE80211_HT40; 2276 #endif 2277 return status; 2278 } 2279 2280 void 2281 ieee80211_media_status(struct ifnet *ifp, struct ifmediareq *imr) 2282 { 2283 struct ieee80211vap *vap = ifp->if_softc; 2284 struct ieee80211com *ic = vap->iv_ic; 2285 enum ieee80211_phymode mode; 2286 struct ieee80211_node_txrate tn; 2287 2288 imr->ifm_status = IFM_AVALID; 2289 /* 2290 * NB: use the current channel's mode to lock down a xmit 2291 * rate only when running; otherwise we may have a mismatch 2292 * in which case the rate will not be convertible. 2293 */ 2294 if (vap->iv_state == IEEE80211_S_RUN || 2295 vap->iv_state == IEEE80211_S_SLEEP) { 2296 imr->ifm_status |= IFM_ACTIVE; 2297 mode = ieee80211_chan2mode(ic->ic_curchan); 2298 } else 2299 mode = IEEE80211_MODE_AUTO; 2300 imr->ifm_active = media_status(vap->iv_opmode, ic->ic_curchan); 2301 /* 2302 * Calculate a current rate if possible. 2303 */ 2304 if (vap->iv_txparms[mode].ucastrate != IEEE80211_FIXED_RATE_NONE) { 2305 /* 2306 * A fixed rate is set, report that. 2307 */ 2308 tn = IEEE80211_NODE_TXRATE_INIT_LEGACY( 2309 vap->iv_txparms[mode].ucastrate); 2310 imr->ifm_active |= ieee80211_rate2media(ic, &tn, mode); 2311 } else if (vap->iv_opmode == IEEE80211_M_STA) { 2312 /* 2313 * In station mode report the current transmit rate. 2314 */ 2315 ieee80211_node_get_txrate(vap->iv_bss, &tn); 2316 imr->ifm_active |= ieee80211_rate2media(ic, &tn, mode); 2317 } else 2318 imr->ifm_active |= IFM_AUTO; 2319 if (imr->ifm_status & IFM_ACTIVE) 2320 imr->ifm_current = imr->ifm_active; 2321 } 2322 2323 /* 2324 * Set the current phy mode and recalculate the active channel 2325 * set based on the available channels for this mode. Also 2326 * select a new default/current channel if the current one is 2327 * inappropriate for this mode. 2328 */ 2329 int 2330 ieee80211_setmode(struct ieee80211com *ic, enum ieee80211_phymode mode) 2331 { 2332 /* 2333 * Adjust basic rates in 11b/11g supported rate set. 2334 * Note that if operating on a hal/quarter rate channel 2335 * this is a noop as those rates sets are different 2336 * and used instead. 2337 */ 2338 if (mode == IEEE80211_MODE_11G || mode == IEEE80211_MODE_11B) 2339 ieee80211_setbasicrates(&ic->ic_sup_rates[mode], mode); 2340 2341 ic->ic_curmode = mode; 2342 ieee80211_reset_erp(ic); /* reset global ERP state */ 2343 2344 return 0; 2345 } 2346 2347 /* 2348 * Return the phy mode for with the specified channel. 2349 */ 2350 enum ieee80211_phymode 2351 ieee80211_chan2mode(const struct ieee80211_channel *chan) 2352 { 2353 2354 if (IEEE80211_IS_CHAN_VHT_2GHZ(chan)) 2355 return IEEE80211_MODE_VHT_2GHZ; 2356 else if (IEEE80211_IS_CHAN_VHT_5GHZ(chan)) 2357 return IEEE80211_MODE_VHT_5GHZ; 2358 else if (IEEE80211_IS_CHAN_HTA(chan)) 2359 return IEEE80211_MODE_11NA; 2360 else if (IEEE80211_IS_CHAN_HTG(chan)) 2361 return IEEE80211_MODE_11NG; 2362 else if (IEEE80211_IS_CHAN_108G(chan)) 2363 return IEEE80211_MODE_TURBO_G; 2364 else if (IEEE80211_IS_CHAN_ST(chan)) 2365 return IEEE80211_MODE_STURBO_A; 2366 else if (IEEE80211_IS_CHAN_TURBO(chan)) 2367 return IEEE80211_MODE_TURBO_A; 2368 else if (IEEE80211_IS_CHAN_HALF(chan)) 2369 return IEEE80211_MODE_HALF; 2370 else if (IEEE80211_IS_CHAN_QUARTER(chan)) 2371 return IEEE80211_MODE_QUARTER; 2372 else if (IEEE80211_IS_CHAN_A(chan)) 2373 return IEEE80211_MODE_11A; 2374 else if (IEEE80211_IS_CHAN_ANYG(chan)) 2375 return IEEE80211_MODE_11G; 2376 else if (IEEE80211_IS_CHAN_B(chan)) 2377 return IEEE80211_MODE_11B; 2378 else if (IEEE80211_IS_CHAN_FHSS(chan)) 2379 return IEEE80211_MODE_FH; 2380 2381 /* NB: should not get here */ 2382 printf("%s: cannot map channel to mode; freq %u flags 0x%x\n", 2383 __func__, chan->ic_freq, chan->ic_flags); 2384 return IEEE80211_MODE_11B; 2385 } 2386 2387 struct ratemedia { 2388 u_int match; /* rate + mode */ 2389 u_int media; /* if_media rate */ 2390 }; 2391 2392 static int 2393 findmedia(const struct ratemedia rates[], int n, u_int match) 2394 { 2395 int i; 2396 2397 for (i = 0; i < n; i++) 2398 if (rates[i].match == match) 2399 return rates[i].media; 2400 return IFM_AUTO; 2401 } 2402 2403 /* 2404 * Convert IEEE80211 rate value to ifmedia subtype. 2405 * Rate is either a legacy rate in units of 0.5Mbps 2406 * or an MCS index. 2407 */ 2408 int 2409 ieee80211_rate2media(struct ieee80211com *ic, 2410 const struct ieee80211_node_txrate *tr, enum ieee80211_phymode mode) 2411 { 2412 static const struct ratemedia rates[] = { 2413 { 2 | IFM_IEEE80211_FH, IFM_IEEE80211_FH1 }, 2414 { 4 | IFM_IEEE80211_FH, IFM_IEEE80211_FH2 }, 2415 { 2 | IFM_IEEE80211_11B, IFM_IEEE80211_DS1 }, 2416 { 4 | IFM_IEEE80211_11B, IFM_IEEE80211_DS2 }, 2417 { 11 | IFM_IEEE80211_11B, IFM_IEEE80211_DS5 }, 2418 { 22 | IFM_IEEE80211_11B, IFM_IEEE80211_DS11 }, 2419 { 44 | IFM_IEEE80211_11B, IFM_IEEE80211_DS22 }, 2420 { 12 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM6 }, 2421 { 18 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM9 }, 2422 { 24 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM12 }, 2423 { 36 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM18 }, 2424 { 48 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM24 }, 2425 { 72 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM36 }, 2426 { 96 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM48 }, 2427 { 108 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM54 }, 2428 { 2 | IFM_IEEE80211_11G, IFM_IEEE80211_DS1 }, 2429 { 4 | IFM_IEEE80211_11G, IFM_IEEE80211_DS2 }, 2430 { 11 | IFM_IEEE80211_11G, IFM_IEEE80211_DS5 }, 2431 { 22 | IFM_IEEE80211_11G, IFM_IEEE80211_DS11 }, 2432 { 12 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM6 }, 2433 { 18 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM9 }, 2434 { 24 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM12 }, 2435 { 36 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM18 }, 2436 { 48 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM24 }, 2437 { 72 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM36 }, 2438 { 96 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM48 }, 2439 { 108 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM54 }, 2440 { 6 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM3 }, 2441 { 9 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM4 }, 2442 { 54 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM27 }, 2443 /* NB: OFDM72 doesn't really exist so we don't handle it */ 2444 }; 2445 static const struct ratemedia htrates[] = { 2446 { 0, IFM_IEEE80211_MCS }, 2447 { 1, IFM_IEEE80211_MCS }, 2448 { 2, IFM_IEEE80211_MCS }, 2449 { 3, IFM_IEEE80211_MCS }, 2450 { 4, IFM_IEEE80211_MCS }, 2451 { 5, IFM_IEEE80211_MCS }, 2452 { 6, IFM_IEEE80211_MCS }, 2453 { 7, IFM_IEEE80211_MCS }, 2454 { 8, IFM_IEEE80211_MCS }, 2455 { 9, IFM_IEEE80211_MCS }, 2456 { 10, IFM_IEEE80211_MCS }, 2457 { 11, IFM_IEEE80211_MCS }, 2458 { 12, IFM_IEEE80211_MCS }, 2459 { 13, IFM_IEEE80211_MCS }, 2460 { 14, IFM_IEEE80211_MCS }, 2461 { 15, IFM_IEEE80211_MCS }, 2462 { 16, IFM_IEEE80211_MCS }, 2463 { 17, IFM_IEEE80211_MCS }, 2464 { 18, IFM_IEEE80211_MCS }, 2465 { 19, IFM_IEEE80211_MCS }, 2466 { 20, IFM_IEEE80211_MCS }, 2467 { 21, IFM_IEEE80211_MCS }, 2468 { 22, IFM_IEEE80211_MCS }, 2469 { 23, IFM_IEEE80211_MCS }, 2470 { 24, IFM_IEEE80211_MCS }, 2471 { 25, IFM_IEEE80211_MCS }, 2472 { 26, IFM_IEEE80211_MCS }, 2473 { 27, IFM_IEEE80211_MCS }, 2474 { 28, IFM_IEEE80211_MCS }, 2475 { 29, IFM_IEEE80211_MCS }, 2476 { 30, IFM_IEEE80211_MCS }, 2477 { 31, IFM_IEEE80211_MCS }, 2478 { 32, IFM_IEEE80211_MCS }, 2479 { 33, IFM_IEEE80211_MCS }, 2480 { 34, IFM_IEEE80211_MCS }, 2481 { 35, IFM_IEEE80211_MCS }, 2482 { 36, IFM_IEEE80211_MCS }, 2483 { 37, IFM_IEEE80211_MCS }, 2484 { 38, IFM_IEEE80211_MCS }, 2485 { 39, IFM_IEEE80211_MCS }, 2486 { 40, IFM_IEEE80211_MCS }, 2487 { 41, IFM_IEEE80211_MCS }, 2488 { 42, IFM_IEEE80211_MCS }, 2489 { 43, IFM_IEEE80211_MCS }, 2490 { 44, IFM_IEEE80211_MCS }, 2491 { 45, IFM_IEEE80211_MCS }, 2492 { 46, IFM_IEEE80211_MCS }, 2493 { 47, IFM_IEEE80211_MCS }, 2494 { 48, IFM_IEEE80211_MCS }, 2495 { 49, IFM_IEEE80211_MCS }, 2496 { 50, IFM_IEEE80211_MCS }, 2497 { 51, IFM_IEEE80211_MCS }, 2498 { 52, IFM_IEEE80211_MCS }, 2499 { 53, IFM_IEEE80211_MCS }, 2500 { 54, IFM_IEEE80211_MCS }, 2501 { 55, IFM_IEEE80211_MCS }, 2502 { 56, IFM_IEEE80211_MCS }, 2503 { 57, IFM_IEEE80211_MCS }, 2504 { 58, IFM_IEEE80211_MCS }, 2505 { 59, IFM_IEEE80211_MCS }, 2506 { 60, IFM_IEEE80211_MCS }, 2507 { 61, IFM_IEEE80211_MCS }, 2508 { 62, IFM_IEEE80211_MCS }, 2509 { 63, IFM_IEEE80211_MCS }, 2510 { 64, IFM_IEEE80211_MCS }, 2511 { 65, IFM_IEEE80211_MCS }, 2512 { 66, IFM_IEEE80211_MCS }, 2513 { 67, IFM_IEEE80211_MCS }, 2514 { 68, IFM_IEEE80211_MCS }, 2515 { 69, IFM_IEEE80211_MCS }, 2516 { 70, IFM_IEEE80211_MCS }, 2517 { 71, IFM_IEEE80211_MCS }, 2518 { 72, IFM_IEEE80211_MCS }, 2519 { 73, IFM_IEEE80211_MCS }, 2520 { 74, IFM_IEEE80211_MCS }, 2521 { 75, IFM_IEEE80211_MCS }, 2522 { 76, IFM_IEEE80211_MCS }, 2523 }; 2524 static const struct ratemedia vhtrates[] = { 2525 { 0, IFM_IEEE80211_VHT }, 2526 { 1, IFM_IEEE80211_VHT }, 2527 { 2, IFM_IEEE80211_VHT }, 2528 { 3, IFM_IEEE80211_VHT }, 2529 { 4, IFM_IEEE80211_VHT }, 2530 { 5, IFM_IEEE80211_VHT }, 2531 { 6, IFM_IEEE80211_VHT }, 2532 { 7, IFM_IEEE80211_VHT }, 2533 { 8, IFM_IEEE80211_VHT }, /* Optional. */ 2534 { 9, IFM_IEEE80211_VHT }, /* Optional. */ 2535 #if 0 2536 /* Some QCA and BRCM seem to support this; offspec. */ 2537 { 10, IFM_IEEE80211_VHT }, 2538 { 11, IFM_IEEE80211_VHT }, 2539 #endif 2540 }; 2541 int m, rate; 2542 2543 /* 2544 * Check 11ac/11n rates first for match as an MCS. 2545 */ 2546 if (mode == IEEE80211_MODE_VHT_5GHZ) { 2547 if (tr->type == IEEE80211_NODE_TXRATE_VHT) { 2548 m = findmedia(vhtrates, nitems(vhtrates), tr->mcs); 2549 if (m != IFM_AUTO) 2550 return (m | IFM_IEEE80211_VHT); 2551 } 2552 } else if (mode == IEEE80211_MODE_11NA) { 2553 /* NB: 12 is ambiguous, it will be treated as an MCS */ 2554 if (tr->type == IEEE80211_NODE_TXRATE_HT) { 2555 m = findmedia(htrates, nitems(htrates), 2556 tr->dot11rate & ~IEEE80211_RATE_MCS); 2557 if (m != IFM_AUTO) 2558 return m | IFM_IEEE80211_11NA; 2559 } 2560 } else if (mode == IEEE80211_MODE_11NG) { 2561 /* NB: 12 is ambiguous, it will be treated as an MCS */ 2562 if (tr->type == IEEE80211_NODE_TXRATE_HT) { 2563 m = findmedia(htrates, nitems(htrates), 2564 tr->dot11rate & ~IEEE80211_RATE_MCS); 2565 if (m != IFM_AUTO) 2566 return m | IFM_IEEE80211_11NG; 2567 } 2568 } 2569 2570 /* 2571 * At this point it needs to be a dot11rate (legacy/HT) for the 2572 * rest of the logic to work. 2573 */ 2574 if ((tr->type != IEEE80211_NODE_TXRATE_LEGACY) && 2575 (tr->type != IEEE80211_NODE_TXRATE_HT)) 2576 return (IFM_AUTO); 2577 rate = tr->dot11rate & IEEE80211_RATE_VAL; 2578 2579 switch (mode) { 2580 case IEEE80211_MODE_11A: 2581 case IEEE80211_MODE_HALF: /* XXX good 'nuf */ 2582 case IEEE80211_MODE_QUARTER: 2583 case IEEE80211_MODE_11NA: 2584 case IEEE80211_MODE_TURBO_A: 2585 case IEEE80211_MODE_STURBO_A: 2586 return findmedia(rates, nitems(rates), 2587 rate | IFM_IEEE80211_11A); 2588 case IEEE80211_MODE_11B: 2589 return findmedia(rates, nitems(rates), 2590 rate | IFM_IEEE80211_11B); 2591 case IEEE80211_MODE_FH: 2592 return findmedia(rates, nitems(rates), 2593 rate | IFM_IEEE80211_FH); 2594 case IEEE80211_MODE_AUTO: 2595 /* NB: ic may be NULL for some drivers */ 2596 if (ic != NULL && ic->ic_phytype == IEEE80211_T_FH) 2597 return findmedia(rates, nitems(rates), 2598 rate | IFM_IEEE80211_FH); 2599 /* NB: hack, 11g matches both 11b+11a rates */ 2600 /* fall thru... */ 2601 case IEEE80211_MODE_11G: 2602 case IEEE80211_MODE_11NG: 2603 case IEEE80211_MODE_TURBO_G: 2604 return findmedia(rates, nitems(rates), rate | IFM_IEEE80211_11G); 2605 case IEEE80211_MODE_VHT_2GHZ: 2606 case IEEE80211_MODE_VHT_5GHZ: 2607 /* XXX TODO: need to figure out mapping for VHT rates */ 2608 return IFM_AUTO; 2609 } 2610 return IFM_AUTO; 2611 } 2612 2613 int 2614 ieee80211_media2rate(int mword) 2615 { 2616 static const int ieeerates[] = { 2617 -1, /* IFM_AUTO */ 2618 0, /* IFM_MANUAL */ 2619 0, /* IFM_NONE */ 2620 2, /* IFM_IEEE80211_FH1 */ 2621 4, /* IFM_IEEE80211_FH2 */ 2622 2, /* IFM_IEEE80211_DS1 */ 2623 4, /* IFM_IEEE80211_DS2 */ 2624 11, /* IFM_IEEE80211_DS5 */ 2625 22, /* IFM_IEEE80211_DS11 */ 2626 44, /* IFM_IEEE80211_DS22 */ 2627 12, /* IFM_IEEE80211_OFDM6 */ 2628 18, /* IFM_IEEE80211_OFDM9 */ 2629 24, /* IFM_IEEE80211_OFDM12 */ 2630 36, /* IFM_IEEE80211_OFDM18 */ 2631 48, /* IFM_IEEE80211_OFDM24 */ 2632 72, /* IFM_IEEE80211_OFDM36 */ 2633 96, /* IFM_IEEE80211_OFDM48 */ 2634 108, /* IFM_IEEE80211_OFDM54 */ 2635 144, /* IFM_IEEE80211_OFDM72 */ 2636 0, /* IFM_IEEE80211_DS354k */ 2637 0, /* IFM_IEEE80211_DS512k */ 2638 6, /* IFM_IEEE80211_OFDM3 */ 2639 9, /* IFM_IEEE80211_OFDM4 */ 2640 54, /* IFM_IEEE80211_OFDM27 */ 2641 -1, /* IFM_IEEE80211_MCS */ 2642 -1, /* IFM_IEEE80211_VHT */ 2643 }; 2644 return IFM_SUBTYPE(mword) < nitems(ieeerates) ? 2645 ieeerates[IFM_SUBTYPE(mword)] : 0; 2646 } 2647 2648 /* 2649 * The following hash function is adapted from "Hash Functions" by Bob Jenkins 2650 * ("Algorithm Alley", Dr. Dobbs Journal, September 1997). 2651 */ 2652 #define mix(a, b, c) \ 2653 do { \ 2654 a -= b; a -= c; a ^= (c >> 13); \ 2655 b -= c; b -= a; b ^= (a << 8); \ 2656 c -= a; c -= b; c ^= (b >> 13); \ 2657 a -= b; a -= c; a ^= (c >> 12); \ 2658 b -= c; b -= a; b ^= (a << 16); \ 2659 c -= a; c -= b; c ^= (b >> 5); \ 2660 a -= b; a -= c; a ^= (c >> 3); \ 2661 b -= c; b -= a; b ^= (a << 10); \ 2662 c -= a; c -= b; c ^= (b >> 15); \ 2663 } while (/*CONSTCOND*/0) 2664 2665 uint32_t 2666 ieee80211_mac_hash(const struct ieee80211com *ic, 2667 const uint8_t addr[IEEE80211_ADDR_LEN]) 2668 { 2669 uint32_t a = 0x9e3779b9, b = 0x9e3779b9, c = ic->ic_hash_key; 2670 2671 b += addr[5] << 8; 2672 b += addr[4]; 2673 a += addr[3] << 24; 2674 a += addr[2] << 16; 2675 a += addr[1] << 8; 2676 a += addr[0]; 2677 2678 mix(a, b, c); 2679 2680 return c; 2681 } 2682 #undef mix 2683 2684 char 2685 ieee80211_channel_type_char(const struct ieee80211_channel *c) 2686 { 2687 if (IEEE80211_IS_CHAN_ST(c)) 2688 return 'S'; 2689 if (IEEE80211_IS_CHAN_108A(c)) 2690 return 'T'; 2691 if (IEEE80211_IS_CHAN_108G(c)) 2692 return 'G'; 2693 if (IEEE80211_IS_CHAN_VHT(c)) 2694 return 'v'; 2695 if (IEEE80211_IS_CHAN_HT(c)) 2696 return 'n'; 2697 if (IEEE80211_IS_CHAN_A(c)) 2698 return 'a'; 2699 if (IEEE80211_IS_CHAN_ANYG(c)) 2700 return 'g'; 2701 if (IEEE80211_IS_CHAN_B(c)) 2702 return 'b'; 2703 return 'f'; 2704 } 2705 2706 /* 2707 * Determine whether the given key in the given VAP is a global key. 2708 * (key index 0..3, shared between all stations on a VAP.) 2709 * 2710 * This is either a WEP key or a GROUP key. 2711 * 2712 * Note this will NOT return true if it is a IGTK key. 2713 */ 2714 bool 2715 ieee80211_is_key_global(const struct ieee80211vap *vap, 2716 const struct ieee80211_key *key) 2717 { 2718 return (&vap->iv_nw_keys[0] <= key && 2719 key < &vap->iv_nw_keys[IEEE80211_WEP_NKID]); 2720 } 2721 2722 /* 2723 * Determine whether the given key in the given VAP is a unicast key. 2724 */ 2725 bool 2726 ieee80211_is_key_unicast(const struct ieee80211vap *vap, 2727 const struct ieee80211_key *key) 2728 { 2729 /* 2730 * This is a short-cut for now; eventually we will need 2731 * to support multiple unicast keys, IGTK, etc) so we 2732 * will absolutely need to fix the key flags. 2733 */ 2734 return (!ieee80211_is_key_global(vap, key)); 2735 } 2736 2737 /** 2738 * Determine whether the given control frame is from a known node 2739 * and destined to us. 2740 * 2741 * In some instances a control frame won't have a TA (eg ACKs), so 2742 * we should only verify the RA for those. 2743 * 2744 * @param ni ieee80211_node representing the sender, or BSS node 2745 * @param m0 mbuf representing the 802.11 frame. 2746 * @returns false if the frame is not a CTL frame (with a warning logged); 2747 * true if the frame is from a known sender / valid recipient, 2748 * false otherwise. 2749 */ 2750 bool 2751 ieee80211_is_ctl_frame_for_vap(struct ieee80211_node *ni, const struct mbuf *m0) 2752 { 2753 const struct ieee80211vap *vap = ni->ni_vap; 2754 const struct ieee80211_frame *wh; 2755 uint8_t subtype; 2756 2757 wh = mtod(m0, const struct ieee80211_frame *); 2758 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2759 2760 /* Verify it's a ctl frame. */ 2761 KASSERT(IEEE80211_IS_CTL(wh), ("%s: not a CTL frame (fc[0]=0x%04x)", 2762 __func__, wh->i_fc[0])); 2763 if (!IEEE80211_IS_CTL(wh)) { 2764 if_printf(vap->iv_ifp, 2765 "%s: not a control frame (fc[0]=0x%04x)\n", 2766 __func__, wh->i_fc[0]); 2767 return (false); 2768 } 2769 2770 /* Verify the TA if present. */ 2771 switch (subtype) { 2772 case IEEE80211_FC0_SUBTYPE_CTS: 2773 case IEEE80211_FC0_SUBTYPE_ACK: 2774 /* No TA. */ 2775 break; 2776 default: 2777 /* 2778 * Verify TA matches ni->ni_macaddr; for unknown 2779 * sources it will be the BSS node and ni->ni_macaddr 2780 * will the BSS MAC. 2781 */ 2782 if (!IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) 2783 return (false); 2784 break; 2785 } 2786 2787 /* Verify the RA */ 2788 return (IEEE80211_ADDR_EQ(wh->i_addr1, vap->iv_myaddr)); 2789 } 2790