1 /*- 2 * Copyright (c) 2001 Atsushi Onoe 3 * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 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 39 #include <sys/socket.h> 40 41 #include <net/if.h> 42 #include <net/if_dl.h> 43 #include <net/if_media.h> 44 #include <net/if_types.h> 45 #include <net/ethernet.h> 46 47 #include <net80211/ieee80211_var.h> 48 #include <net80211/ieee80211_regdomain.h> 49 #ifdef IEEE80211_SUPPORT_SUPERG 50 #include <net80211/ieee80211_superg.h> 51 #endif 52 #include <net80211/ieee80211_ratectl.h> 53 54 #include <net/bpf.h> 55 56 const char *ieee80211_phymode_name[IEEE80211_MODE_MAX] = { 57 [IEEE80211_MODE_AUTO] = "auto", 58 [IEEE80211_MODE_11A] = "11a", 59 [IEEE80211_MODE_11B] = "11b", 60 [IEEE80211_MODE_11G] = "11g", 61 [IEEE80211_MODE_FH] = "FH", 62 [IEEE80211_MODE_TURBO_A] = "turboA", 63 [IEEE80211_MODE_TURBO_G] = "turboG", 64 [IEEE80211_MODE_STURBO_A] = "sturboA", 65 [IEEE80211_MODE_HALF] = "half", 66 [IEEE80211_MODE_QUARTER] = "quarter", 67 [IEEE80211_MODE_11NA] = "11na", 68 [IEEE80211_MODE_11NG] = "11ng", 69 }; 70 /* map ieee80211_opmode to the corresponding capability bit */ 71 const int ieee80211_opcap[IEEE80211_OPMODE_MAX] = { 72 [IEEE80211_M_IBSS] = IEEE80211_C_IBSS, 73 [IEEE80211_M_WDS] = IEEE80211_C_WDS, 74 [IEEE80211_M_STA] = IEEE80211_C_STA, 75 [IEEE80211_M_AHDEMO] = IEEE80211_C_AHDEMO, 76 [IEEE80211_M_HOSTAP] = IEEE80211_C_HOSTAP, 77 [IEEE80211_M_MONITOR] = IEEE80211_C_MONITOR, 78 #ifdef IEEE80211_SUPPORT_MESH 79 [IEEE80211_M_MBSS] = IEEE80211_C_MBSS, 80 #endif 81 }; 82 83 static const uint8_t ieee80211broadcastaddr[IEEE80211_ADDR_LEN] = 84 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 85 86 static void ieee80211_syncflag_locked(struct ieee80211com *ic, int flag); 87 static void ieee80211_syncflag_ht_locked(struct ieee80211com *ic, int flag); 88 static void ieee80211_syncflag_ext_locked(struct ieee80211com *ic, int flag); 89 static int ieee80211_media_setup(struct ieee80211com *ic, 90 struct ifmedia *media, int caps, int addsta, 91 ifm_change_cb_t media_change, ifm_stat_cb_t media_stat); 92 static void ieee80211com_media_status(struct ifnet *, struct ifmediareq *); 93 static int ieee80211com_media_change(struct ifnet *); 94 static int media_status(enum ieee80211_opmode, 95 const struct ieee80211_channel *); 96 97 MALLOC_DEFINE(M_80211_VAP, "80211vap", "802.11 vap state"); 98 99 /* 100 * Default supported rates for 802.11 operation (in IEEE .5Mb units). 101 */ 102 #define B(r) ((r) | IEEE80211_RATE_BASIC) 103 static const struct ieee80211_rateset ieee80211_rateset_11a = 104 { 8, { B(12), 18, B(24), 36, B(48), 72, 96, 108 } }; 105 static const struct ieee80211_rateset ieee80211_rateset_half = 106 { 8, { B(6), 9, B(12), 18, B(24), 36, 48, 54 } }; 107 static const struct ieee80211_rateset ieee80211_rateset_quarter = 108 { 8, { B(3), 4, B(6), 9, B(12), 18, 24, 27 } }; 109 static const struct ieee80211_rateset ieee80211_rateset_11b = 110 { 4, { B(2), B(4), B(11), B(22) } }; 111 /* NB: OFDM rates are handled specially based on mode */ 112 static const struct ieee80211_rateset ieee80211_rateset_11g = 113 { 12, { B(2), B(4), B(11), B(22), 12, 18, 24, 36, 48, 72, 96, 108 } }; 114 #undef B 115 116 /* 117 * Fill in 802.11 available channel set, mark 118 * all available channels as active, and pick 119 * a default channel if not already specified. 120 */ 121 static void 122 ieee80211_chan_init(struct ieee80211com *ic) 123 { 124 #define DEFAULTRATES(m, def) do { \ 125 if (ic->ic_sup_rates[m].rs_nrates == 0) \ 126 ic->ic_sup_rates[m] = def; \ 127 } while (0) 128 struct ieee80211_channel *c; 129 int i; 130 131 KASSERT(0 < ic->ic_nchans && ic->ic_nchans <= IEEE80211_CHAN_MAX, 132 ("invalid number of channels specified: %u", ic->ic_nchans)); 133 memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail)); 134 memset(ic->ic_modecaps, 0, sizeof(ic->ic_modecaps)); 135 setbit(ic->ic_modecaps, IEEE80211_MODE_AUTO); 136 for (i = 0; i < ic->ic_nchans; i++) { 137 c = &ic->ic_channels[i]; 138 KASSERT(c->ic_flags != 0, ("channel with no flags")); 139 /* 140 * Help drivers that work only with frequencies by filling 141 * in IEEE channel #'s if not already calculated. Note this 142 * mimics similar work done in ieee80211_setregdomain when 143 * changing regulatory state. 144 */ 145 if (c->ic_ieee == 0) 146 c->ic_ieee = ieee80211_mhz2ieee(c->ic_freq,c->ic_flags); 147 if (IEEE80211_IS_CHAN_HT40(c) && c->ic_extieee == 0) 148 c->ic_extieee = ieee80211_mhz2ieee(c->ic_freq + 149 (IEEE80211_IS_CHAN_HT40U(c) ? 20 : -20), 150 c->ic_flags); 151 /* default max tx power to max regulatory */ 152 if (c->ic_maxpower == 0) 153 c->ic_maxpower = 2*c->ic_maxregpower; 154 setbit(ic->ic_chan_avail, c->ic_ieee); 155 /* 156 * Identify mode capabilities. 157 */ 158 if (IEEE80211_IS_CHAN_A(c)) 159 setbit(ic->ic_modecaps, IEEE80211_MODE_11A); 160 if (IEEE80211_IS_CHAN_B(c)) 161 setbit(ic->ic_modecaps, IEEE80211_MODE_11B); 162 if (IEEE80211_IS_CHAN_ANYG(c)) 163 setbit(ic->ic_modecaps, IEEE80211_MODE_11G); 164 if (IEEE80211_IS_CHAN_FHSS(c)) 165 setbit(ic->ic_modecaps, IEEE80211_MODE_FH); 166 if (IEEE80211_IS_CHAN_108A(c)) 167 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_A); 168 if (IEEE80211_IS_CHAN_108G(c)) 169 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_G); 170 if (IEEE80211_IS_CHAN_ST(c)) 171 setbit(ic->ic_modecaps, IEEE80211_MODE_STURBO_A); 172 if (IEEE80211_IS_CHAN_HALF(c)) 173 setbit(ic->ic_modecaps, IEEE80211_MODE_HALF); 174 if (IEEE80211_IS_CHAN_QUARTER(c)) 175 setbit(ic->ic_modecaps, IEEE80211_MODE_QUARTER); 176 if (IEEE80211_IS_CHAN_HTA(c)) 177 setbit(ic->ic_modecaps, IEEE80211_MODE_11NA); 178 if (IEEE80211_IS_CHAN_HTG(c)) 179 setbit(ic->ic_modecaps, IEEE80211_MODE_11NG); 180 } 181 /* initialize candidate channels to all available */ 182 memcpy(ic->ic_chan_active, ic->ic_chan_avail, 183 sizeof(ic->ic_chan_avail)); 184 185 /* sort channel table to allow lookup optimizations */ 186 ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans); 187 188 /* invalidate any previous state */ 189 ic->ic_bsschan = IEEE80211_CHAN_ANYC; 190 ic->ic_prevchan = NULL; 191 ic->ic_csa_newchan = NULL; 192 /* arbitrarily pick the first channel */ 193 ic->ic_curchan = &ic->ic_channels[0]; 194 ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan); 195 196 /* fillin well-known rate sets if driver has not specified */ 197 DEFAULTRATES(IEEE80211_MODE_11B, ieee80211_rateset_11b); 198 DEFAULTRATES(IEEE80211_MODE_11G, ieee80211_rateset_11g); 199 DEFAULTRATES(IEEE80211_MODE_11A, ieee80211_rateset_11a); 200 DEFAULTRATES(IEEE80211_MODE_TURBO_A, ieee80211_rateset_11a); 201 DEFAULTRATES(IEEE80211_MODE_TURBO_G, ieee80211_rateset_11g); 202 DEFAULTRATES(IEEE80211_MODE_STURBO_A, ieee80211_rateset_11a); 203 DEFAULTRATES(IEEE80211_MODE_HALF, ieee80211_rateset_half); 204 DEFAULTRATES(IEEE80211_MODE_QUARTER, ieee80211_rateset_quarter); 205 DEFAULTRATES(IEEE80211_MODE_11NA, ieee80211_rateset_11a); 206 DEFAULTRATES(IEEE80211_MODE_11NG, ieee80211_rateset_11g); 207 208 /* 209 * Setup required information to fill the mcsset field, if driver did 210 * not. Assume a 2T2R setup for historic reasons. 211 */ 212 if (ic->ic_rxstream == 0) 213 ic->ic_rxstream = 2; 214 if (ic->ic_txstream == 0) 215 ic->ic_txstream = 2; 216 217 /* 218 * Set auto mode to reset active channel state and any desired channel. 219 */ 220 (void) ieee80211_setmode(ic, IEEE80211_MODE_AUTO); 221 #undef DEFAULTRATES 222 } 223 224 static void 225 null_update_mcast(struct ifnet *ifp) 226 { 227 if_printf(ifp, "need multicast update callback\n"); 228 } 229 230 static void 231 null_update_promisc(struct ifnet *ifp) 232 { 233 if_printf(ifp, "need promiscuous mode update callback\n"); 234 } 235 236 static int 237 null_transmit(struct ifnet *ifp, struct mbuf *m) 238 { 239 m_freem(m); 240 ifp->if_oerrors++; 241 return EACCES; /* XXX EIO/EPERM? */ 242 } 243 244 static int 245 null_output(struct ifnet *ifp, struct mbuf *m, 246 struct sockaddr *dst, struct route *ro) 247 { 248 if_printf(ifp, "discard raw packet\n"); 249 return null_transmit(ifp, m); 250 } 251 252 static void 253 null_input(struct ifnet *ifp, struct mbuf *m) 254 { 255 if_printf(ifp, "if_input should not be called\n"); 256 m_freem(m); 257 } 258 259 /* 260 * Attach/setup the common net80211 state. Called by 261 * the driver on attach to prior to creating any vap's. 262 */ 263 void 264 ieee80211_ifattach(struct ieee80211com *ic, 265 const uint8_t macaddr[IEEE80211_ADDR_LEN]) 266 { 267 struct ifnet *ifp = ic->ic_ifp; 268 struct sockaddr_dl *sdl; 269 struct ifaddr *ifa; 270 271 KASSERT(ifp->if_type == IFT_IEEE80211, ("if_type %d", ifp->if_type)); 272 273 IEEE80211_LOCK_INIT(ic, ifp->if_xname); 274 TAILQ_INIT(&ic->ic_vaps); 275 276 /* Create a taskqueue for all state changes */ 277 ic->ic_tq = taskqueue_create("ic_taskq", M_WAITOK | M_ZERO, 278 taskqueue_thread_enqueue, &ic->ic_tq); 279 taskqueue_start_threads(&ic->ic_tq, 1, PI_NET, "%s net80211 taskq", 280 ifp->if_xname); 281 /* 282 * Fill in 802.11 available channel set, mark all 283 * available channels as active, and pick a default 284 * channel if not already specified. 285 */ 286 ieee80211_media_init(ic); 287 288 ic->ic_update_mcast = null_update_mcast; 289 ic->ic_update_promisc = null_update_promisc; 290 291 ic->ic_hash_key = arc4random(); 292 ic->ic_bintval = IEEE80211_BINTVAL_DEFAULT; 293 ic->ic_lintval = ic->ic_bintval; 294 ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX; 295 296 ieee80211_crypto_attach(ic); 297 ieee80211_node_attach(ic); 298 ieee80211_power_attach(ic); 299 ieee80211_proto_attach(ic); 300 #ifdef IEEE80211_SUPPORT_SUPERG 301 ieee80211_superg_attach(ic); 302 #endif 303 ieee80211_ht_attach(ic); 304 ieee80211_scan_attach(ic); 305 ieee80211_regdomain_attach(ic); 306 ieee80211_dfs_attach(ic); 307 308 ieee80211_sysctl_attach(ic); 309 310 ifp->if_addrlen = IEEE80211_ADDR_LEN; 311 ifp->if_hdrlen = 0; 312 if_attach(ifp); 313 ifp->if_mtu = IEEE80211_MTU_MAX; 314 ifp->if_broadcastaddr = ieee80211broadcastaddr; 315 ifp->if_output = null_output; 316 ifp->if_input = null_input; /* just in case */ 317 ifp->if_resolvemulti = NULL; /* NB: callers check */ 318 319 ifa = ifaddr_byindex(ifp->if_index); 320 KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__)); 321 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 322 sdl->sdl_type = IFT_ETHER; /* XXX IFT_IEEE80211? */ 323 sdl->sdl_alen = IEEE80211_ADDR_LEN; 324 IEEE80211_ADDR_COPY(LLADDR(sdl), macaddr); 325 ifa_free(ifa); 326 } 327 328 /* 329 * Detach net80211 state on device detach. Tear down 330 * all vap's and reclaim all common state prior to the 331 * device state going away. Note we may call back into 332 * driver; it must be prepared for this. 333 */ 334 void 335 ieee80211_ifdetach(struct ieee80211com *ic) 336 { 337 struct ifnet *ifp = ic->ic_ifp; 338 struct ieee80211vap *vap; 339 340 if_detach(ifp); 341 342 while ((vap = TAILQ_FIRST(&ic->ic_vaps)) != NULL) 343 ieee80211_vap_destroy(vap); 344 ieee80211_waitfor_parent(ic); 345 346 ieee80211_sysctl_detach(ic); 347 ieee80211_dfs_detach(ic); 348 ieee80211_regdomain_detach(ic); 349 ieee80211_scan_detach(ic); 350 #ifdef IEEE80211_SUPPORT_SUPERG 351 ieee80211_superg_detach(ic); 352 #endif 353 ieee80211_ht_detach(ic); 354 /* NB: must be called before ieee80211_node_detach */ 355 ieee80211_proto_detach(ic); 356 ieee80211_crypto_detach(ic); 357 ieee80211_power_detach(ic); 358 ieee80211_node_detach(ic); 359 360 ifmedia_removeall(&ic->ic_media); 361 taskqueue_free(ic->ic_tq); 362 IEEE80211_LOCK_DESTROY(ic); 363 } 364 365 /* 366 * Default reset method for use with the ioctl support. This 367 * method is invoked after any state change in the 802.11 368 * layer that should be propagated to the hardware but not 369 * require re-initialization of the 802.11 state machine (e.g 370 * rescanning for an ap). We always return ENETRESET which 371 * should cause the driver to re-initialize the device. Drivers 372 * can override this method to implement more optimized support. 373 */ 374 static int 375 default_reset(struct ieee80211vap *vap, u_long cmd) 376 { 377 return ENETRESET; 378 } 379 380 /* 381 * Prepare a vap for use. Drivers use this call to 382 * setup net80211 state in new vap's prior attaching 383 * them with ieee80211_vap_attach (below). 384 */ 385 int 386 ieee80211_vap_setup(struct ieee80211com *ic, struct ieee80211vap *vap, 387 const char name[IFNAMSIZ], int unit, enum ieee80211_opmode opmode, 388 int flags, const uint8_t bssid[IEEE80211_ADDR_LEN], 389 const uint8_t macaddr[IEEE80211_ADDR_LEN]) 390 { 391 struct ifnet *ifp; 392 393 ifp = if_alloc(IFT_ETHER); 394 if (ifp == NULL) { 395 if_printf(ic->ic_ifp, "%s: unable to allocate ifnet\n", 396 __func__); 397 return ENOMEM; 398 } 399 if_initname(ifp, name, unit); 400 ifp->if_softc = vap; /* back pointer */ 401 ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST; 402 ifp->if_start = ieee80211_start; 403 ifp->if_ioctl = ieee80211_ioctl; 404 ifp->if_init = ieee80211_init; 405 /* NB: input+output filled in by ether_ifattach */ 406 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); 407 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; 408 IFQ_SET_READY(&ifp->if_snd); 409 410 vap->iv_ifp = ifp; 411 vap->iv_ic = ic; 412 vap->iv_flags = ic->ic_flags; /* propagate common flags */ 413 vap->iv_flags_ext = ic->ic_flags_ext; 414 vap->iv_flags_ven = ic->ic_flags_ven; 415 vap->iv_caps = ic->ic_caps &~ IEEE80211_C_OPMODE; 416 vap->iv_htcaps = ic->ic_htcaps; 417 vap->iv_htextcaps = ic->ic_htextcaps; 418 vap->iv_opmode = opmode; 419 vap->iv_caps |= ieee80211_opcap[opmode]; 420 switch (opmode) { 421 case IEEE80211_M_WDS: 422 /* 423 * WDS links must specify the bssid of the far end. 424 * For legacy operation this is a static relationship. 425 * For non-legacy operation the station must associate 426 * and be authorized to pass traffic. Plumbing the 427 * vap to the proper node happens when the vap 428 * transitions to RUN state. 429 */ 430 IEEE80211_ADDR_COPY(vap->iv_des_bssid, bssid); 431 vap->iv_flags |= IEEE80211_F_DESBSSID; 432 if (flags & IEEE80211_CLONE_WDSLEGACY) 433 vap->iv_flags_ext |= IEEE80211_FEXT_WDSLEGACY; 434 break; 435 #ifdef IEEE80211_SUPPORT_TDMA 436 case IEEE80211_M_AHDEMO: 437 if (flags & IEEE80211_CLONE_TDMA) { 438 /* NB: checked before clone operation allowed */ 439 KASSERT(ic->ic_caps & IEEE80211_C_TDMA, 440 ("not TDMA capable, ic_caps 0x%x", ic->ic_caps)); 441 /* 442 * Propagate TDMA capability to mark vap; this 443 * cannot be removed and is used to distinguish 444 * regular ahdemo operation from ahdemo+tdma. 445 */ 446 vap->iv_caps |= IEEE80211_C_TDMA; 447 } 448 break; 449 #endif 450 default: 451 break; 452 } 453 /* auto-enable s/w beacon miss support */ 454 if (flags & IEEE80211_CLONE_NOBEACONS) 455 vap->iv_flags_ext |= IEEE80211_FEXT_SWBMISS; 456 /* auto-generated or user supplied MAC address */ 457 if (flags & (IEEE80211_CLONE_BSSID|IEEE80211_CLONE_MACADDR)) 458 vap->iv_flags_ext |= IEEE80211_FEXT_UNIQMAC; 459 /* 460 * Enable various functionality by default if we're 461 * capable; the driver can override us if it knows better. 462 */ 463 if (vap->iv_caps & IEEE80211_C_WME) 464 vap->iv_flags |= IEEE80211_F_WME; 465 if (vap->iv_caps & IEEE80211_C_BURST) 466 vap->iv_flags |= IEEE80211_F_BURST; 467 /* NB: bg scanning only makes sense for station mode right now */ 468 if (vap->iv_opmode == IEEE80211_M_STA && 469 (vap->iv_caps & IEEE80211_C_BGSCAN)) 470 vap->iv_flags |= IEEE80211_F_BGSCAN; 471 vap->iv_flags |= IEEE80211_F_DOTH; /* XXX no cap, just ena */ 472 /* NB: DFS support only makes sense for ap mode right now */ 473 if (vap->iv_opmode == IEEE80211_M_HOSTAP && 474 (vap->iv_caps & IEEE80211_C_DFS)) 475 vap->iv_flags_ext |= IEEE80211_FEXT_DFS; 476 477 vap->iv_des_chan = IEEE80211_CHAN_ANYC; /* any channel is ok */ 478 vap->iv_bmissthreshold = IEEE80211_HWBMISS_DEFAULT; 479 vap->iv_dtim_period = IEEE80211_DTIM_DEFAULT; 480 /* 481 * Install a default reset method for the ioctl support; 482 * the driver can override this. 483 */ 484 vap->iv_reset = default_reset; 485 486 IEEE80211_ADDR_COPY(vap->iv_myaddr, macaddr); 487 488 ieee80211_sysctl_vattach(vap); 489 ieee80211_crypto_vattach(vap); 490 ieee80211_node_vattach(vap); 491 ieee80211_power_vattach(vap); 492 ieee80211_proto_vattach(vap); 493 #ifdef IEEE80211_SUPPORT_SUPERG 494 ieee80211_superg_vattach(vap); 495 #endif 496 ieee80211_ht_vattach(vap); 497 ieee80211_scan_vattach(vap); 498 ieee80211_regdomain_vattach(vap); 499 ieee80211_radiotap_vattach(vap); 500 ieee80211_ratectl_set(vap, IEEE80211_RATECTL_NONE); 501 502 return 0; 503 } 504 505 /* 506 * Activate a vap. State should have been prepared with a 507 * call to ieee80211_vap_setup and by the driver. On return 508 * from this call the vap is ready for use. 509 */ 510 int 511 ieee80211_vap_attach(struct ieee80211vap *vap, 512 ifm_change_cb_t media_change, ifm_stat_cb_t media_stat) 513 { 514 struct ifnet *ifp = vap->iv_ifp; 515 struct ieee80211com *ic = vap->iv_ic; 516 struct ifmediareq imr; 517 int maxrate; 518 519 IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, 520 "%s: %s parent %s flags 0x%x flags_ext 0x%x\n", 521 __func__, ieee80211_opmode_name[vap->iv_opmode], 522 ic->ic_ifp->if_xname, vap->iv_flags, vap->iv_flags_ext); 523 524 /* 525 * Do late attach work that cannot happen until after 526 * the driver has had a chance to override defaults. 527 */ 528 ieee80211_node_latevattach(vap); 529 ieee80211_power_latevattach(vap); 530 531 maxrate = ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps, 532 vap->iv_opmode == IEEE80211_M_STA, media_change, media_stat); 533 ieee80211_media_status(ifp, &imr); 534 /* NB: strip explicit mode; we're actually in autoselect */ 535 ifmedia_set(&vap->iv_media, 536 imr.ifm_active &~ (IFM_MMASK | IFM_IEEE80211_TURBO)); 537 if (maxrate) 538 ifp->if_baudrate = IF_Mbps(maxrate); 539 540 ether_ifattach(ifp, vap->iv_myaddr); 541 if (vap->iv_opmode == IEEE80211_M_MONITOR) { 542 /* NB: disallow transmit */ 543 ifp->if_transmit = null_transmit; 544 ifp->if_output = null_output; 545 } else { 546 /* hook output method setup by ether_ifattach */ 547 vap->iv_output = ifp->if_output; 548 ifp->if_output = ieee80211_output; 549 } 550 /* NB: if_mtu set by ether_ifattach to ETHERMTU */ 551 552 IEEE80211_LOCK(ic); 553 TAILQ_INSERT_TAIL(&ic->ic_vaps, vap, iv_next); 554 ieee80211_syncflag_locked(ic, IEEE80211_F_WME); 555 #ifdef IEEE80211_SUPPORT_SUPERG 556 ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP); 557 #endif 558 ieee80211_syncflag_locked(ic, IEEE80211_F_PCF); 559 ieee80211_syncflag_locked(ic, IEEE80211_F_BURST); 560 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT); 561 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40); 562 ieee80211_syncifflag_locked(ic, IFF_PROMISC); 563 ieee80211_syncifflag_locked(ic, IFF_ALLMULTI); 564 IEEE80211_UNLOCK(ic); 565 566 return 1; 567 } 568 569 /* 570 * Tear down vap state and reclaim the ifnet. 571 * The driver is assumed to have prepared for 572 * this; e.g. by turning off interrupts for the 573 * underlying device. 574 */ 575 void 576 ieee80211_vap_detach(struct ieee80211vap *vap) 577 { 578 struct ieee80211com *ic = vap->iv_ic; 579 struct ifnet *ifp = vap->iv_ifp; 580 581 IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s parent %s\n", 582 __func__, ieee80211_opmode_name[vap->iv_opmode], 583 ic->ic_ifp->if_xname); 584 585 /* NB: bpfdetach is called by ether_ifdetach and claims all taps */ 586 ether_ifdetach(ifp); 587 588 ieee80211_stop(vap); 589 590 /* 591 * Flush any deferred vap tasks. 592 */ 593 ieee80211_draintask(ic, &vap->iv_nstate_task); 594 ieee80211_draintask(ic, &vap->iv_swbmiss_task); 595 596 /* XXX band-aid until ifnet handles this for us */ 597 taskqueue_drain(taskqueue_swi, &ifp->if_linktask); 598 599 IEEE80211_LOCK(ic); 600 KASSERT(vap->iv_state == IEEE80211_S_INIT , ("vap still running")); 601 TAILQ_REMOVE(&ic->ic_vaps, vap, iv_next); 602 ieee80211_syncflag_locked(ic, IEEE80211_F_WME); 603 #ifdef IEEE80211_SUPPORT_SUPERG 604 ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP); 605 #endif 606 ieee80211_syncflag_locked(ic, IEEE80211_F_PCF); 607 ieee80211_syncflag_locked(ic, IEEE80211_F_BURST); 608 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT); 609 ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40); 610 /* NB: this handles the bpfdetach done below */ 611 ieee80211_syncflag_ext_locked(ic, IEEE80211_FEXT_BPF); 612 ieee80211_syncifflag_locked(ic, IFF_PROMISC); 613 ieee80211_syncifflag_locked(ic, IFF_ALLMULTI); 614 IEEE80211_UNLOCK(ic); 615 616 ifmedia_removeall(&vap->iv_media); 617 618 ieee80211_radiotap_vdetach(vap); 619 ieee80211_regdomain_vdetach(vap); 620 ieee80211_scan_vdetach(vap); 621 #ifdef IEEE80211_SUPPORT_SUPERG 622 ieee80211_superg_vdetach(vap); 623 #endif 624 ieee80211_ht_vdetach(vap); 625 /* NB: must be before ieee80211_node_vdetach */ 626 ieee80211_proto_vdetach(vap); 627 ieee80211_crypto_vdetach(vap); 628 ieee80211_power_vdetach(vap); 629 ieee80211_node_vdetach(vap); 630 ieee80211_sysctl_vdetach(vap); 631 632 if_free(ifp); 633 } 634 635 /* 636 * Synchronize flag bit state in the parent ifnet structure 637 * according to the state of all vap ifnet's. This is used, 638 * for example, to handle IFF_PROMISC and IFF_ALLMULTI. 639 */ 640 void 641 ieee80211_syncifflag_locked(struct ieee80211com *ic, int flag) 642 { 643 struct ifnet *ifp = ic->ic_ifp; 644 struct ieee80211vap *vap; 645 int bit, oflags; 646 647 IEEE80211_LOCK_ASSERT(ic); 648 649 bit = 0; 650 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 651 if (vap->iv_ifp->if_flags & flag) { 652 /* 653 * XXX the bridge sets PROMISC but we don't want to 654 * enable it on the device, discard here so all the 655 * drivers don't need to special-case it 656 */ 657 if (flag == IFF_PROMISC && 658 !(vap->iv_opmode == IEEE80211_M_MONITOR || 659 (vap->iv_opmode == IEEE80211_M_AHDEMO && 660 (vap->iv_caps & IEEE80211_C_TDMA) == 0))) 661 continue; 662 bit = 1; 663 break; 664 } 665 oflags = ifp->if_flags; 666 if (bit) 667 ifp->if_flags |= flag; 668 else 669 ifp->if_flags &= ~flag; 670 if ((ifp->if_flags ^ oflags) & flag) { 671 /* XXX should we return 1/0 and let caller do this? */ 672 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 673 if (flag == IFF_PROMISC) 674 ieee80211_runtask(ic, &ic->ic_promisc_task); 675 else if (flag == IFF_ALLMULTI) 676 ieee80211_runtask(ic, &ic->ic_mcast_task); 677 } 678 } 679 } 680 681 /* 682 * Synchronize flag bit state in the com structure 683 * according to the state of all vap's. This is used, 684 * for example, to handle state changes via ioctls. 685 */ 686 static void 687 ieee80211_syncflag_locked(struct ieee80211com *ic, int flag) 688 { 689 struct ieee80211vap *vap; 690 int bit; 691 692 IEEE80211_LOCK_ASSERT(ic); 693 694 bit = 0; 695 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 696 if (vap->iv_flags & flag) { 697 bit = 1; 698 break; 699 } 700 if (bit) 701 ic->ic_flags |= flag; 702 else 703 ic->ic_flags &= ~flag; 704 } 705 706 void 707 ieee80211_syncflag(struct ieee80211vap *vap, int flag) 708 { 709 struct ieee80211com *ic = vap->iv_ic; 710 711 IEEE80211_LOCK(ic); 712 if (flag < 0) { 713 flag = -flag; 714 vap->iv_flags &= ~flag; 715 } else 716 vap->iv_flags |= flag; 717 ieee80211_syncflag_locked(ic, flag); 718 IEEE80211_UNLOCK(ic); 719 } 720 721 /* 722 * Synchronize flags_ht bit state in the com structure 723 * according to the state of all vap's. This is used, 724 * for example, to handle state changes via ioctls. 725 */ 726 static void 727 ieee80211_syncflag_ht_locked(struct ieee80211com *ic, int flag) 728 { 729 struct ieee80211vap *vap; 730 int bit; 731 732 IEEE80211_LOCK_ASSERT(ic); 733 734 bit = 0; 735 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 736 if (vap->iv_flags_ht & flag) { 737 bit = 1; 738 break; 739 } 740 if (bit) 741 ic->ic_flags_ht |= flag; 742 else 743 ic->ic_flags_ht &= ~flag; 744 } 745 746 void 747 ieee80211_syncflag_ht(struct ieee80211vap *vap, int flag) 748 { 749 struct ieee80211com *ic = vap->iv_ic; 750 751 IEEE80211_LOCK(ic); 752 if (flag < 0) { 753 flag = -flag; 754 vap->iv_flags_ht &= ~flag; 755 } else 756 vap->iv_flags_ht |= flag; 757 ieee80211_syncflag_ht_locked(ic, flag); 758 IEEE80211_UNLOCK(ic); 759 } 760 761 /* 762 * Synchronize flags_ext bit state in the com structure 763 * according to the state of all vap's. This is used, 764 * for example, to handle state changes via ioctls. 765 */ 766 static void 767 ieee80211_syncflag_ext_locked(struct ieee80211com *ic, int flag) 768 { 769 struct ieee80211vap *vap; 770 int bit; 771 772 IEEE80211_LOCK_ASSERT(ic); 773 774 bit = 0; 775 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 776 if (vap->iv_flags_ext & flag) { 777 bit = 1; 778 break; 779 } 780 if (bit) 781 ic->ic_flags_ext |= flag; 782 else 783 ic->ic_flags_ext &= ~flag; 784 } 785 786 void 787 ieee80211_syncflag_ext(struct ieee80211vap *vap, int flag) 788 { 789 struct ieee80211com *ic = vap->iv_ic; 790 791 IEEE80211_LOCK(ic); 792 if (flag < 0) { 793 flag = -flag; 794 vap->iv_flags_ext &= ~flag; 795 } else 796 vap->iv_flags_ext |= flag; 797 ieee80211_syncflag_ext_locked(ic, flag); 798 IEEE80211_UNLOCK(ic); 799 } 800 801 static __inline int 802 mapgsm(u_int freq, u_int flags) 803 { 804 freq *= 10; 805 if (flags & IEEE80211_CHAN_QUARTER) 806 freq += 5; 807 else if (flags & IEEE80211_CHAN_HALF) 808 freq += 10; 809 else 810 freq += 20; 811 /* NB: there is no 907/20 wide but leave room */ 812 return (freq - 906*10) / 5; 813 } 814 815 static __inline int 816 mappsb(u_int freq, u_int flags) 817 { 818 return 37 + ((freq * 10) + ((freq % 5) == 2 ? 5 : 0) - 49400) / 5; 819 } 820 821 /* 822 * Convert MHz frequency to IEEE channel number. 823 */ 824 int 825 ieee80211_mhz2ieee(u_int freq, u_int flags) 826 { 827 #define IS_FREQ_IN_PSB(_freq) ((_freq) > 4940 && (_freq) < 4990) 828 if (flags & IEEE80211_CHAN_GSM) 829 return mapgsm(freq, flags); 830 if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */ 831 if (freq == 2484) 832 return 14; 833 if (freq < 2484) 834 return ((int) freq - 2407) / 5; 835 else 836 return 15 + ((freq - 2512) / 20); 837 } else if (flags & IEEE80211_CHAN_5GHZ) { /* 5Ghz band */ 838 if (freq <= 5000) { 839 /* XXX check regdomain? */ 840 if (IS_FREQ_IN_PSB(freq)) 841 return mappsb(freq, flags); 842 return (freq - 4000) / 5; 843 } else 844 return (freq - 5000) / 5; 845 } else { /* either, guess */ 846 if (freq == 2484) 847 return 14; 848 if (freq < 2484) { 849 if (907 <= freq && freq <= 922) 850 return mapgsm(freq, flags); 851 return ((int) freq - 2407) / 5; 852 } 853 if (freq < 5000) { 854 if (IS_FREQ_IN_PSB(freq)) 855 return mappsb(freq, flags); 856 else if (freq > 4900) 857 return (freq - 4000) / 5; 858 else 859 return 15 + ((freq - 2512) / 20); 860 } 861 return (freq - 5000) / 5; 862 } 863 #undef IS_FREQ_IN_PSB 864 } 865 866 /* 867 * Convert channel to IEEE channel number. 868 */ 869 int 870 ieee80211_chan2ieee(struct ieee80211com *ic, const struct ieee80211_channel *c) 871 { 872 if (c == NULL) { 873 if_printf(ic->ic_ifp, "invalid channel (NULL)\n"); 874 return 0; /* XXX */ 875 } 876 return (c == IEEE80211_CHAN_ANYC ? IEEE80211_CHAN_ANY : c->ic_ieee); 877 } 878 879 /* 880 * Convert IEEE channel number to MHz frequency. 881 */ 882 u_int 883 ieee80211_ieee2mhz(u_int chan, u_int flags) 884 { 885 if (flags & IEEE80211_CHAN_GSM) 886 return 907 + 5 * (chan / 10); 887 if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */ 888 if (chan == 14) 889 return 2484; 890 if (chan < 14) 891 return 2407 + chan*5; 892 else 893 return 2512 + ((chan-15)*20); 894 } else if (flags & IEEE80211_CHAN_5GHZ) {/* 5Ghz band */ 895 if (flags & (IEEE80211_CHAN_HALF|IEEE80211_CHAN_QUARTER)) { 896 chan -= 37; 897 return 4940 + chan*5 + (chan % 5 ? 2 : 0); 898 } 899 return 5000 + (chan*5); 900 } else { /* either, guess */ 901 /* XXX can't distinguish PSB+GSM channels */ 902 if (chan == 14) 903 return 2484; 904 if (chan < 14) /* 0-13 */ 905 return 2407 + chan*5; 906 if (chan < 27) /* 15-26 */ 907 return 2512 + ((chan-15)*20); 908 return 5000 + (chan*5); 909 } 910 } 911 912 /* 913 * Locate a channel given a frequency+flags. We cache 914 * the previous lookup to optimize switching between two 915 * channels--as happens with dynamic turbo. 916 */ 917 struct ieee80211_channel * 918 ieee80211_find_channel(struct ieee80211com *ic, int freq, int flags) 919 { 920 struct ieee80211_channel *c; 921 int i; 922 923 flags &= IEEE80211_CHAN_ALLTURBO; 924 c = ic->ic_prevchan; 925 if (c != NULL && c->ic_freq == freq && 926 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 927 return c; 928 /* brute force search */ 929 for (i = 0; i < ic->ic_nchans; i++) { 930 c = &ic->ic_channels[i]; 931 if (c->ic_freq == freq && 932 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 933 return c; 934 } 935 return NULL; 936 } 937 938 /* 939 * Locate a channel given a channel number+flags. We cache 940 * the previous lookup to optimize switching between two 941 * channels--as happens with dynamic turbo. 942 */ 943 struct ieee80211_channel * 944 ieee80211_find_channel_byieee(struct ieee80211com *ic, int ieee, int flags) 945 { 946 struct ieee80211_channel *c; 947 int i; 948 949 flags &= IEEE80211_CHAN_ALLTURBO; 950 c = ic->ic_prevchan; 951 if (c != NULL && c->ic_ieee == ieee && 952 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 953 return c; 954 /* brute force search */ 955 for (i = 0; i < ic->ic_nchans; i++) { 956 c = &ic->ic_channels[i]; 957 if (c->ic_ieee == ieee && 958 (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) 959 return c; 960 } 961 return NULL; 962 } 963 964 static void 965 addmedia(struct ifmedia *media, int caps, int addsta, int mode, int mword) 966 { 967 #define ADD(_ic, _s, _o) \ 968 ifmedia_add(media, \ 969 IFM_MAKEWORD(IFM_IEEE80211, (_s), (_o), 0), 0, NULL) 970 static const u_int mopts[IEEE80211_MODE_MAX] = { 971 [IEEE80211_MODE_AUTO] = IFM_AUTO, 972 [IEEE80211_MODE_11A] = IFM_IEEE80211_11A, 973 [IEEE80211_MODE_11B] = IFM_IEEE80211_11B, 974 [IEEE80211_MODE_11G] = IFM_IEEE80211_11G, 975 [IEEE80211_MODE_FH] = IFM_IEEE80211_FH, 976 [IEEE80211_MODE_TURBO_A] = IFM_IEEE80211_11A|IFM_IEEE80211_TURBO, 977 [IEEE80211_MODE_TURBO_G] = IFM_IEEE80211_11G|IFM_IEEE80211_TURBO, 978 [IEEE80211_MODE_STURBO_A] = IFM_IEEE80211_11A|IFM_IEEE80211_TURBO, 979 [IEEE80211_MODE_HALF] = IFM_IEEE80211_11A, /* XXX */ 980 [IEEE80211_MODE_QUARTER] = IFM_IEEE80211_11A, /* XXX */ 981 [IEEE80211_MODE_11NA] = IFM_IEEE80211_11NA, 982 [IEEE80211_MODE_11NG] = IFM_IEEE80211_11NG, 983 }; 984 u_int mopt; 985 986 mopt = mopts[mode]; 987 if (addsta) 988 ADD(ic, mword, mopt); /* STA mode has no cap */ 989 if (caps & IEEE80211_C_IBSS) 990 ADD(media, mword, mopt | IFM_IEEE80211_ADHOC); 991 if (caps & IEEE80211_C_HOSTAP) 992 ADD(media, mword, mopt | IFM_IEEE80211_HOSTAP); 993 if (caps & IEEE80211_C_AHDEMO) 994 ADD(media, mword, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0); 995 if (caps & IEEE80211_C_MONITOR) 996 ADD(media, mword, mopt | IFM_IEEE80211_MONITOR); 997 if (caps & IEEE80211_C_WDS) 998 ADD(media, mword, mopt | IFM_IEEE80211_WDS); 999 if (caps & IEEE80211_C_MBSS) 1000 ADD(media, mword, mopt | IFM_IEEE80211_MBSS); 1001 #undef ADD 1002 } 1003 1004 /* 1005 * Setup the media data structures according to the channel and 1006 * rate tables. 1007 */ 1008 static int 1009 ieee80211_media_setup(struct ieee80211com *ic, 1010 struct ifmedia *media, int caps, int addsta, 1011 ifm_change_cb_t media_change, ifm_stat_cb_t media_stat) 1012 { 1013 int i, j, rate, maxrate, mword, r; 1014 enum ieee80211_phymode mode; 1015 const struct ieee80211_rateset *rs; 1016 struct ieee80211_rateset allrates; 1017 1018 /* 1019 * Fill in media characteristics. 1020 */ 1021 ifmedia_init(media, 0, media_change, media_stat); 1022 maxrate = 0; 1023 /* 1024 * Add media for legacy operating modes. 1025 */ 1026 memset(&allrates, 0, sizeof(allrates)); 1027 for (mode = IEEE80211_MODE_AUTO; mode < IEEE80211_MODE_11NA; mode++) { 1028 if (isclr(ic->ic_modecaps, mode)) 1029 continue; 1030 addmedia(media, caps, addsta, mode, IFM_AUTO); 1031 if (mode == IEEE80211_MODE_AUTO) 1032 continue; 1033 rs = &ic->ic_sup_rates[mode]; 1034 for (i = 0; i < rs->rs_nrates; i++) { 1035 rate = rs->rs_rates[i]; 1036 mword = ieee80211_rate2media(ic, rate, mode); 1037 if (mword == 0) 1038 continue; 1039 addmedia(media, caps, addsta, mode, mword); 1040 /* 1041 * Add legacy rate to the collection of all rates. 1042 */ 1043 r = rate & IEEE80211_RATE_VAL; 1044 for (j = 0; j < allrates.rs_nrates; j++) 1045 if (allrates.rs_rates[j] == r) 1046 break; 1047 if (j == allrates.rs_nrates) { 1048 /* unique, add to the set */ 1049 allrates.rs_rates[j] = r; 1050 allrates.rs_nrates++; 1051 } 1052 rate = (rate & IEEE80211_RATE_VAL) / 2; 1053 if (rate > maxrate) 1054 maxrate = rate; 1055 } 1056 } 1057 for (i = 0; i < allrates.rs_nrates; i++) { 1058 mword = ieee80211_rate2media(ic, allrates.rs_rates[i], 1059 IEEE80211_MODE_AUTO); 1060 if (mword == 0) 1061 continue; 1062 /* NB: remove media options from mword */ 1063 addmedia(media, caps, addsta, 1064 IEEE80211_MODE_AUTO, IFM_SUBTYPE(mword)); 1065 } 1066 /* 1067 * Add HT/11n media. Note that we do not have enough 1068 * bits in the media subtype to express the MCS so we 1069 * use a "placeholder" media subtype and any fixed MCS 1070 * must be specified with a different mechanism. 1071 */ 1072 for (; mode <= IEEE80211_MODE_11NG; mode++) { 1073 if (isclr(ic->ic_modecaps, mode)) 1074 continue; 1075 addmedia(media, caps, addsta, mode, IFM_AUTO); 1076 addmedia(media, caps, addsta, mode, IFM_IEEE80211_MCS); 1077 } 1078 if (isset(ic->ic_modecaps, IEEE80211_MODE_11NA) || 1079 isset(ic->ic_modecaps, IEEE80211_MODE_11NG)) { 1080 addmedia(media, caps, addsta, 1081 IEEE80211_MODE_AUTO, IFM_IEEE80211_MCS); 1082 i = ic->ic_txstream * 8 - 1; 1083 if ((ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40) && 1084 (ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI40)) 1085 rate = ieee80211_htrates[i].ht40_rate_400ns; 1086 else if ((ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40)) 1087 rate = ieee80211_htrates[i].ht40_rate_800ns; 1088 else if ((ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI20)) 1089 rate = ieee80211_htrates[i].ht20_rate_400ns; 1090 else 1091 rate = ieee80211_htrates[i].ht20_rate_800ns; 1092 if (rate > maxrate) 1093 maxrate = rate; 1094 } 1095 return maxrate; 1096 } 1097 1098 void 1099 ieee80211_media_init(struct ieee80211com *ic) 1100 { 1101 struct ifnet *ifp = ic->ic_ifp; 1102 int maxrate; 1103 1104 /* NB: this works because the structure is initialized to zero */ 1105 if (!LIST_EMPTY(&ic->ic_media.ifm_list)) { 1106 /* 1107 * We are re-initializing the channel list; clear 1108 * the existing media state as the media routines 1109 * don't suppress duplicates. 1110 */ 1111 ifmedia_removeall(&ic->ic_media); 1112 } 1113 ieee80211_chan_init(ic); 1114 1115 /* 1116 * Recalculate media settings in case new channel list changes 1117 * the set of available modes. 1118 */ 1119 maxrate = ieee80211_media_setup(ic, &ic->ic_media, ic->ic_caps, 1, 1120 ieee80211com_media_change, ieee80211com_media_status); 1121 /* NB: strip explicit mode; we're actually in autoselect */ 1122 ifmedia_set(&ic->ic_media, 1123 media_status(ic->ic_opmode, ic->ic_curchan) &~ 1124 (IFM_MMASK | IFM_IEEE80211_TURBO)); 1125 if (maxrate) 1126 ifp->if_baudrate = IF_Mbps(maxrate); 1127 1128 /* XXX need to propagate new media settings to vap's */ 1129 } 1130 1131 /* XXX inline or eliminate? */ 1132 const struct ieee80211_rateset * 1133 ieee80211_get_suprates(struct ieee80211com *ic, const struct ieee80211_channel *c) 1134 { 1135 /* XXX does this work for 11ng basic rates? */ 1136 return &ic->ic_sup_rates[ieee80211_chan2mode(c)]; 1137 } 1138 1139 void 1140 ieee80211_announce(struct ieee80211com *ic) 1141 { 1142 struct ifnet *ifp = ic->ic_ifp; 1143 int i, rate, mword; 1144 enum ieee80211_phymode mode; 1145 const struct ieee80211_rateset *rs; 1146 1147 /* NB: skip AUTO since it has no rates */ 1148 for (mode = IEEE80211_MODE_AUTO+1; mode < IEEE80211_MODE_11NA; mode++) { 1149 if (isclr(ic->ic_modecaps, mode)) 1150 continue; 1151 if_printf(ifp, "%s rates: ", ieee80211_phymode_name[mode]); 1152 rs = &ic->ic_sup_rates[mode]; 1153 for (i = 0; i < rs->rs_nrates; i++) { 1154 mword = ieee80211_rate2media(ic, rs->rs_rates[i], mode); 1155 if (mword == 0) 1156 continue; 1157 rate = ieee80211_media2rate(mword); 1158 printf("%s%d%sMbps", (i != 0 ? " " : ""), 1159 rate / 2, ((rate & 0x1) != 0 ? ".5" : "")); 1160 } 1161 printf("\n"); 1162 } 1163 ieee80211_ht_announce(ic); 1164 } 1165 1166 void 1167 ieee80211_announce_channels(struct ieee80211com *ic) 1168 { 1169 const struct ieee80211_channel *c; 1170 char type; 1171 int i, cw; 1172 1173 printf("Chan Freq CW RegPwr MinPwr MaxPwr\n"); 1174 for (i = 0; i < ic->ic_nchans; i++) { 1175 c = &ic->ic_channels[i]; 1176 if (IEEE80211_IS_CHAN_ST(c)) 1177 type = 'S'; 1178 else if (IEEE80211_IS_CHAN_108A(c)) 1179 type = 'T'; 1180 else if (IEEE80211_IS_CHAN_108G(c)) 1181 type = 'G'; 1182 else if (IEEE80211_IS_CHAN_HT(c)) 1183 type = 'n'; 1184 else if (IEEE80211_IS_CHAN_A(c)) 1185 type = 'a'; 1186 else if (IEEE80211_IS_CHAN_ANYG(c)) 1187 type = 'g'; 1188 else if (IEEE80211_IS_CHAN_B(c)) 1189 type = 'b'; 1190 else 1191 type = 'f'; 1192 if (IEEE80211_IS_CHAN_HT40(c) || IEEE80211_IS_CHAN_TURBO(c)) 1193 cw = 40; 1194 else if (IEEE80211_IS_CHAN_HALF(c)) 1195 cw = 10; 1196 else if (IEEE80211_IS_CHAN_QUARTER(c)) 1197 cw = 5; 1198 else 1199 cw = 20; 1200 printf("%4d %4d%c %2d%c %6d %4d.%d %4d.%d\n" 1201 , c->ic_ieee, c->ic_freq, type 1202 , cw 1203 , IEEE80211_IS_CHAN_HT40U(c) ? '+' : 1204 IEEE80211_IS_CHAN_HT40D(c) ? '-' : ' ' 1205 , c->ic_maxregpower 1206 , c->ic_minpower / 2, c->ic_minpower & 1 ? 5 : 0 1207 , c->ic_maxpower / 2, c->ic_maxpower & 1 ? 5 : 0 1208 ); 1209 } 1210 } 1211 1212 static int 1213 media2mode(const struct ifmedia_entry *ime, uint32_t flags, uint16_t *mode) 1214 { 1215 switch (IFM_MODE(ime->ifm_media)) { 1216 case IFM_IEEE80211_11A: 1217 *mode = IEEE80211_MODE_11A; 1218 break; 1219 case IFM_IEEE80211_11B: 1220 *mode = IEEE80211_MODE_11B; 1221 break; 1222 case IFM_IEEE80211_11G: 1223 *mode = IEEE80211_MODE_11G; 1224 break; 1225 case IFM_IEEE80211_FH: 1226 *mode = IEEE80211_MODE_FH; 1227 break; 1228 case IFM_IEEE80211_11NA: 1229 *mode = IEEE80211_MODE_11NA; 1230 break; 1231 case IFM_IEEE80211_11NG: 1232 *mode = IEEE80211_MODE_11NG; 1233 break; 1234 case IFM_AUTO: 1235 *mode = IEEE80211_MODE_AUTO; 1236 break; 1237 default: 1238 return 0; 1239 } 1240 /* 1241 * Turbo mode is an ``option''. 1242 * XXX does not apply to AUTO 1243 */ 1244 if (ime->ifm_media & IFM_IEEE80211_TURBO) { 1245 if (*mode == IEEE80211_MODE_11A) { 1246 if (flags & IEEE80211_F_TURBOP) 1247 *mode = IEEE80211_MODE_TURBO_A; 1248 else 1249 *mode = IEEE80211_MODE_STURBO_A; 1250 } else if (*mode == IEEE80211_MODE_11G) 1251 *mode = IEEE80211_MODE_TURBO_G; 1252 else 1253 return 0; 1254 } 1255 /* XXX HT40 +/- */ 1256 return 1; 1257 } 1258 1259 /* 1260 * Handle a media change request on the underlying interface. 1261 */ 1262 int 1263 ieee80211com_media_change(struct ifnet *ifp) 1264 { 1265 return EINVAL; 1266 } 1267 1268 /* 1269 * Handle a media change request on the vap interface. 1270 */ 1271 int 1272 ieee80211_media_change(struct ifnet *ifp) 1273 { 1274 struct ieee80211vap *vap = ifp->if_softc; 1275 struct ifmedia_entry *ime = vap->iv_media.ifm_cur; 1276 uint16_t newmode; 1277 1278 if (!media2mode(ime, vap->iv_flags, &newmode)) 1279 return EINVAL; 1280 if (vap->iv_des_mode != newmode) { 1281 vap->iv_des_mode = newmode; 1282 /* XXX kick state machine if up+running */ 1283 } 1284 return 0; 1285 } 1286 1287 /* 1288 * Common code to calculate the media status word 1289 * from the operating mode and channel state. 1290 */ 1291 static int 1292 media_status(enum ieee80211_opmode opmode, const struct ieee80211_channel *chan) 1293 { 1294 int status; 1295 1296 status = IFM_IEEE80211; 1297 switch (opmode) { 1298 case IEEE80211_M_STA: 1299 break; 1300 case IEEE80211_M_IBSS: 1301 status |= IFM_IEEE80211_ADHOC; 1302 break; 1303 case IEEE80211_M_HOSTAP: 1304 status |= IFM_IEEE80211_HOSTAP; 1305 break; 1306 case IEEE80211_M_MONITOR: 1307 status |= IFM_IEEE80211_MONITOR; 1308 break; 1309 case IEEE80211_M_AHDEMO: 1310 status |= IFM_IEEE80211_ADHOC | IFM_FLAG0; 1311 break; 1312 case IEEE80211_M_WDS: 1313 status |= IFM_IEEE80211_WDS; 1314 break; 1315 case IEEE80211_M_MBSS: 1316 status |= IFM_IEEE80211_MBSS; 1317 break; 1318 } 1319 if (IEEE80211_IS_CHAN_HTA(chan)) { 1320 status |= IFM_IEEE80211_11NA; 1321 } else if (IEEE80211_IS_CHAN_HTG(chan)) { 1322 status |= IFM_IEEE80211_11NG; 1323 } else if (IEEE80211_IS_CHAN_A(chan)) { 1324 status |= IFM_IEEE80211_11A; 1325 } else if (IEEE80211_IS_CHAN_B(chan)) { 1326 status |= IFM_IEEE80211_11B; 1327 } else if (IEEE80211_IS_CHAN_ANYG(chan)) { 1328 status |= IFM_IEEE80211_11G; 1329 } else if (IEEE80211_IS_CHAN_FHSS(chan)) { 1330 status |= IFM_IEEE80211_FH; 1331 } 1332 /* XXX else complain? */ 1333 1334 if (IEEE80211_IS_CHAN_TURBO(chan)) 1335 status |= IFM_IEEE80211_TURBO; 1336 #if 0 1337 if (IEEE80211_IS_CHAN_HT20(chan)) 1338 status |= IFM_IEEE80211_HT20; 1339 if (IEEE80211_IS_CHAN_HT40(chan)) 1340 status |= IFM_IEEE80211_HT40; 1341 #endif 1342 return status; 1343 } 1344 1345 static void 1346 ieee80211com_media_status(struct ifnet *ifp, struct ifmediareq *imr) 1347 { 1348 struct ieee80211com *ic = ifp->if_l2com; 1349 struct ieee80211vap *vap; 1350 1351 imr->ifm_status = IFM_AVALID; 1352 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) 1353 if (vap->iv_ifp->if_flags & IFF_UP) { 1354 imr->ifm_status |= IFM_ACTIVE; 1355 break; 1356 } 1357 imr->ifm_active = media_status(ic->ic_opmode, ic->ic_curchan); 1358 if (imr->ifm_status & IFM_ACTIVE) 1359 imr->ifm_current = imr->ifm_active; 1360 } 1361 1362 void 1363 ieee80211_media_status(struct ifnet *ifp, struct ifmediareq *imr) 1364 { 1365 struct ieee80211vap *vap = ifp->if_softc; 1366 struct ieee80211com *ic = vap->iv_ic; 1367 enum ieee80211_phymode mode; 1368 1369 imr->ifm_status = IFM_AVALID; 1370 /* 1371 * NB: use the current channel's mode to lock down a xmit 1372 * rate only when running; otherwise we may have a mismatch 1373 * in which case the rate will not be convertible. 1374 */ 1375 if (vap->iv_state == IEEE80211_S_RUN) { 1376 imr->ifm_status |= IFM_ACTIVE; 1377 mode = ieee80211_chan2mode(ic->ic_curchan); 1378 } else 1379 mode = IEEE80211_MODE_AUTO; 1380 imr->ifm_active = media_status(vap->iv_opmode, ic->ic_curchan); 1381 /* 1382 * Calculate a current rate if possible. 1383 */ 1384 if (vap->iv_txparms[mode].ucastrate != IEEE80211_FIXED_RATE_NONE) { 1385 /* 1386 * A fixed rate is set, report that. 1387 */ 1388 imr->ifm_active |= ieee80211_rate2media(ic, 1389 vap->iv_txparms[mode].ucastrate, mode); 1390 } else if (vap->iv_opmode == IEEE80211_M_STA) { 1391 /* 1392 * In station mode report the current transmit rate. 1393 */ 1394 imr->ifm_active |= ieee80211_rate2media(ic, 1395 vap->iv_bss->ni_txrate, mode); 1396 } else 1397 imr->ifm_active |= IFM_AUTO; 1398 if (imr->ifm_status & IFM_ACTIVE) 1399 imr->ifm_current = imr->ifm_active; 1400 } 1401 1402 /* 1403 * Set the current phy mode and recalculate the active channel 1404 * set based on the available channels for this mode. Also 1405 * select a new default/current channel if the current one is 1406 * inappropriate for this mode. 1407 */ 1408 int 1409 ieee80211_setmode(struct ieee80211com *ic, enum ieee80211_phymode mode) 1410 { 1411 /* 1412 * Adjust basic rates in 11b/11g supported rate set. 1413 * Note that if operating on a hal/quarter rate channel 1414 * this is a noop as those rates sets are different 1415 * and used instead. 1416 */ 1417 if (mode == IEEE80211_MODE_11G || mode == IEEE80211_MODE_11B) 1418 ieee80211_setbasicrates(&ic->ic_sup_rates[mode], mode); 1419 1420 ic->ic_curmode = mode; 1421 ieee80211_reset_erp(ic); /* reset ERP state */ 1422 1423 return 0; 1424 } 1425 1426 /* 1427 * Return the phy mode for with the specified channel. 1428 */ 1429 enum ieee80211_phymode 1430 ieee80211_chan2mode(const struct ieee80211_channel *chan) 1431 { 1432 1433 if (IEEE80211_IS_CHAN_HTA(chan)) 1434 return IEEE80211_MODE_11NA; 1435 else if (IEEE80211_IS_CHAN_HTG(chan)) 1436 return IEEE80211_MODE_11NG; 1437 else if (IEEE80211_IS_CHAN_108G(chan)) 1438 return IEEE80211_MODE_TURBO_G; 1439 else if (IEEE80211_IS_CHAN_ST(chan)) 1440 return IEEE80211_MODE_STURBO_A; 1441 else if (IEEE80211_IS_CHAN_TURBO(chan)) 1442 return IEEE80211_MODE_TURBO_A; 1443 else if (IEEE80211_IS_CHAN_HALF(chan)) 1444 return IEEE80211_MODE_HALF; 1445 else if (IEEE80211_IS_CHAN_QUARTER(chan)) 1446 return IEEE80211_MODE_QUARTER; 1447 else if (IEEE80211_IS_CHAN_A(chan)) 1448 return IEEE80211_MODE_11A; 1449 else if (IEEE80211_IS_CHAN_ANYG(chan)) 1450 return IEEE80211_MODE_11G; 1451 else if (IEEE80211_IS_CHAN_B(chan)) 1452 return IEEE80211_MODE_11B; 1453 else if (IEEE80211_IS_CHAN_FHSS(chan)) 1454 return IEEE80211_MODE_FH; 1455 1456 /* NB: should not get here */ 1457 printf("%s: cannot map channel to mode; freq %u flags 0x%x\n", 1458 __func__, chan->ic_freq, chan->ic_flags); 1459 return IEEE80211_MODE_11B; 1460 } 1461 1462 struct ratemedia { 1463 u_int match; /* rate + mode */ 1464 u_int media; /* if_media rate */ 1465 }; 1466 1467 static int 1468 findmedia(const struct ratemedia rates[], int n, u_int match) 1469 { 1470 int i; 1471 1472 for (i = 0; i < n; i++) 1473 if (rates[i].match == match) 1474 return rates[i].media; 1475 return IFM_AUTO; 1476 } 1477 1478 /* 1479 * Convert IEEE80211 rate value to ifmedia subtype. 1480 * Rate is either a legacy rate in units of 0.5Mbps 1481 * or an MCS index. 1482 */ 1483 int 1484 ieee80211_rate2media(struct ieee80211com *ic, int rate, enum ieee80211_phymode mode) 1485 { 1486 #define N(a) (sizeof(a) / sizeof(a[0])) 1487 static const struct ratemedia rates[] = { 1488 { 2 | IFM_IEEE80211_FH, IFM_IEEE80211_FH1 }, 1489 { 4 | IFM_IEEE80211_FH, IFM_IEEE80211_FH2 }, 1490 { 2 | IFM_IEEE80211_11B, IFM_IEEE80211_DS1 }, 1491 { 4 | IFM_IEEE80211_11B, IFM_IEEE80211_DS2 }, 1492 { 11 | IFM_IEEE80211_11B, IFM_IEEE80211_DS5 }, 1493 { 22 | IFM_IEEE80211_11B, IFM_IEEE80211_DS11 }, 1494 { 44 | IFM_IEEE80211_11B, IFM_IEEE80211_DS22 }, 1495 { 12 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM6 }, 1496 { 18 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM9 }, 1497 { 24 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM12 }, 1498 { 36 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM18 }, 1499 { 48 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM24 }, 1500 { 72 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM36 }, 1501 { 96 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM48 }, 1502 { 108 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM54 }, 1503 { 2 | IFM_IEEE80211_11G, IFM_IEEE80211_DS1 }, 1504 { 4 | IFM_IEEE80211_11G, IFM_IEEE80211_DS2 }, 1505 { 11 | IFM_IEEE80211_11G, IFM_IEEE80211_DS5 }, 1506 { 22 | IFM_IEEE80211_11G, IFM_IEEE80211_DS11 }, 1507 { 12 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM6 }, 1508 { 18 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM9 }, 1509 { 24 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM12 }, 1510 { 36 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM18 }, 1511 { 48 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM24 }, 1512 { 72 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM36 }, 1513 { 96 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM48 }, 1514 { 108 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM54 }, 1515 { 6 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM3 }, 1516 { 9 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM4 }, 1517 { 54 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM27 }, 1518 /* NB: OFDM72 doesn't realy exist so we don't handle it */ 1519 }; 1520 static const struct ratemedia htrates[] = { 1521 { 0, IFM_IEEE80211_MCS }, 1522 { 1, IFM_IEEE80211_MCS }, 1523 { 2, IFM_IEEE80211_MCS }, 1524 { 3, IFM_IEEE80211_MCS }, 1525 { 4, IFM_IEEE80211_MCS }, 1526 { 5, IFM_IEEE80211_MCS }, 1527 { 6, IFM_IEEE80211_MCS }, 1528 { 7, IFM_IEEE80211_MCS }, 1529 { 8, IFM_IEEE80211_MCS }, 1530 { 9, IFM_IEEE80211_MCS }, 1531 { 10, IFM_IEEE80211_MCS }, 1532 { 11, IFM_IEEE80211_MCS }, 1533 { 12, IFM_IEEE80211_MCS }, 1534 { 13, IFM_IEEE80211_MCS }, 1535 { 14, IFM_IEEE80211_MCS }, 1536 { 15, IFM_IEEE80211_MCS }, 1537 { 16, IFM_IEEE80211_MCS }, 1538 { 17, IFM_IEEE80211_MCS }, 1539 { 18, IFM_IEEE80211_MCS }, 1540 { 19, IFM_IEEE80211_MCS }, 1541 { 20, IFM_IEEE80211_MCS }, 1542 { 21, IFM_IEEE80211_MCS }, 1543 { 22, IFM_IEEE80211_MCS }, 1544 { 23, IFM_IEEE80211_MCS }, 1545 { 24, IFM_IEEE80211_MCS }, 1546 { 25, IFM_IEEE80211_MCS }, 1547 { 26, IFM_IEEE80211_MCS }, 1548 { 27, IFM_IEEE80211_MCS }, 1549 { 28, IFM_IEEE80211_MCS }, 1550 { 29, IFM_IEEE80211_MCS }, 1551 { 30, IFM_IEEE80211_MCS }, 1552 { 31, IFM_IEEE80211_MCS }, 1553 { 32, IFM_IEEE80211_MCS }, 1554 { 33, IFM_IEEE80211_MCS }, 1555 { 34, IFM_IEEE80211_MCS }, 1556 { 35, IFM_IEEE80211_MCS }, 1557 { 36, IFM_IEEE80211_MCS }, 1558 { 37, IFM_IEEE80211_MCS }, 1559 { 38, IFM_IEEE80211_MCS }, 1560 { 39, IFM_IEEE80211_MCS }, 1561 { 40, IFM_IEEE80211_MCS }, 1562 { 41, IFM_IEEE80211_MCS }, 1563 { 42, IFM_IEEE80211_MCS }, 1564 { 43, IFM_IEEE80211_MCS }, 1565 { 44, IFM_IEEE80211_MCS }, 1566 { 45, IFM_IEEE80211_MCS }, 1567 { 46, IFM_IEEE80211_MCS }, 1568 { 47, IFM_IEEE80211_MCS }, 1569 { 48, IFM_IEEE80211_MCS }, 1570 { 49, IFM_IEEE80211_MCS }, 1571 { 50, IFM_IEEE80211_MCS }, 1572 { 51, IFM_IEEE80211_MCS }, 1573 { 52, IFM_IEEE80211_MCS }, 1574 { 53, IFM_IEEE80211_MCS }, 1575 { 54, IFM_IEEE80211_MCS }, 1576 { 55, IFM_IEEE80211_MCS }, 1577 { 56, IFM_IEEE80211_MCS }, 1578 { 57, IFM_IEEE80211_MCS }, 1579 { 58, IFM_IEEE80211_MCS }, 1580 { 59, IFM_IEEE80211_MCS }, 1581 { 60, IFM_IEEE80211_MCS }, 1582 { 61, IFM_IEEE80211_MCS }, 1583 { 62, IFM_IEEE80211_MCS }, 1584 { 63, IFM_IEEE80211_MCS }, 1585 { 64, IFM_IEEE80211_MCS }, 1586 { 65, IFM_IEEE80211_MCS }, 1587 { 66, IFM_IEEE80211_MCS }, 1588 { 67, IFM_IEEE80211_MCS }, 1589 { 68, IFM_IEEE80211_MCS }, 1590 { 69, IFM_IEEE80211_MCS }, 1591 { 70, IFM_IEEE80211_MCS }, 1592 { 71, IFM_IEEE80211_MCS }, 1593 { 72, IFM_IEEE80211_MCS }, 1594 { 73, IFM_IEEE80211_MCS }, 1595 { 74, IFM_IEEE80211_MCS }, 1596 { 75, IFM_IEEE80211_MCS }, 1597 { 76, IFM_IEEE80211_MCS }, 1598 }; 1599 int m; 1600 1601 /* 1602 * Check 11n rates first for match as an MCS. 1603 */ 1604 if (mode == IEEE80211_MODE_11NA) { 1605 if (rate & IEEE80211_RATE_MCS) { 1606 rate &= ~IEEE80211_RATE_MCS; 1607 m = findmedia(htrates, N(htrates), rate); 1608 if (m != IFM_AUTO) 1609 return m | IFM_IEEE80211_11NA; 1610 } 1611 } else if (mode == IEEE80211_MODE_11NG) { 1612 /* NB: 12 is ambiguous, it will be treated as an MCS */ 1613 if (rate & IEEE80211_RATE_MCS) { 1614 rate &= ~IEEE80211_RATE_MCS; 1615 m = findmedia(htrates, N(htrates), rate); 1616 if (m != IFM_AUTO) 1617 return m | IFM_IEEE80211_11NG; 1618 } 1619 } 1620 rate &= IEEE80211_RATE_VAL; 1621 switch (mode) { 1622 case IEEE80211_MODE_11A: 1623 case IEEE80211_MODE_HALF: /* XXX good 'nuf */ 1624 case IEEE80211_MODE_QUARTER: 1625 case IEEE80211_MODE_11NA: 1626 case IEEE80211_MODE_TURBO_A: 1627 case IEEE80211_MODE_STURBO_A: 1628 return findmedia(rates, N(rates), rate | IFM_IEEE80211_11A); 1629 case IEEE80211_MODE_11B: 1630 return findmedia(rates, N(rates), rate | IFM_IEEE80211_11B); 1631 case IEEE80211_MODE_FH: 1632 return findmedia(rates, N(rates), rate | IFM_IEEE80211_FH); 1633 case IEEE80211_MODE_AUTO: 1634 /* NB: ic may be NULL for some drivers */ 1635 if (ic != NULL && ic->ic_phytype == IEEE80211_T_FH) 1636 return findmedia(rates, N(rates), 1637 rate | IFM_IEEE80211_FH); 1638 /* NB: hack, 11g matches both 11b+11a rates */ 1639 /* fall thru... */ 1640 case IEEE80211_MODE_11G: 1641 case IEEE80211_MODE_11NG: 1642 case IEEE80211_MODE_TURBO_G: 1643 return findmedia(rates, N(rates), rate | IFM_IEEE80211_11G); 1644 } 1645 return IFM_AUTO; 1646 #undef N 1647 } 1648 1649 int 1650 ieee80211_media2rate(int mword) 1651 { 1652 #define N(a) (sizeof(a) / sizeof(a[0])) 1653 static const int ieeerates[] = { 1654 -1, /* IFM_AUTO */ 1655 0, /* IFM_MANUAL */ 1656 0, /* IFM_NONE */ 1657 2, /* IFM_IEEE80211_FH1 */ 1658 4, /* IFM_IEEE80211_FH2 */ 1659 2, /* IFM_IEEE80211_DS1 */ 1660 4, /* IFM_IEEE80211_DS2 */ 1661 11, /* IFM_IEEE80211_DS5 */ 1662 22, /* IFM_IEEE80211_DS11 */ 1663 44, /* IFM_IEEE80211_DS22 */ 1664 12, /* IFM_IEEE80211_OFDM6 */ 1665 18, /* IFM_IEEE80211_OFDM9 */ 1666 24, /* IFM_IEEE80211_OFDM12 */ 1667 36, /* IFM_IEEE80211_OFDM18 */ 1668 48, /* IFM_IEEE80211_OFDM24 */ 1669 72, /* IFM_IEEE80211_OFDM36 */ 1670 96, /* IFM_IEEE80211_OFDM48 */ 1671 108, /* IFM_IEEE80211_OFDM54 */ 1672 144, /* IFM_IEEE80211_OFDM72 */ 1673 0, /* IFM_IEEE80211_DS354k */ 1674 0, /* IFM_IEEE80211_DS512k */ 1675 6, /* IFM_IEEE80211_OFDM3 */ 1676 9, /* IFM_IEEE80211_OFDM4 */ 1677 54, /* IFM_IEEE80211_OFDM27 */ 1678 -1, /* IFM_IEEE80211_MCS */ 1679 }; 1680 return IFM_SUBTYPE(mword) < N(ieeerates) ? 1681 ieeerates[IFM_SUBTYPE(mword)] : 0; 1682 #undef N 1683 } 1684 1685 /* 1686 * The following hash function is adapted from "Hash Functions" by Bob Jenkins 1687 * ("Algorithm Alley", Dr. Dobbs Journal, September 1997). 1688 */ 1689 #define mix(a, b, c) \ 1690 do { \ 1691 a -= b; a -= c; a ^= (c >> 13); \ 1692 b -= c; b -= a; b ^= (a << 8); \ 1693 c -= a; c -= b; c ^= (b >> 13); \ 1694 a -= b; a -= c; a ^= (c >> 12); \ 1695 b -= c; b -= a; b ^= (a << 16); \ 1696 c -= a; c -= b; c ^= (b >> 5); \ 1697 a -= b; a -= c; a ^= (c >> 3); \ 1698 b -= c; b -= a; b ^= (a << 10); \ 1699 c -= a; c -= b; c ^= (b >> 15); \ 1700 } while (/*CONSTCOND*/0) 1701 1702 uint32_t 1703 ieee80211_mac_hash(const struct ieee80211com *ic, 1704 const uint8_t addr[IEEE80211_ADDR_LEN]) 1705 { 1706 uint32_t a = 0x9e3779b9, b = 0x9e3779b9, c = ic->ic_hash_key; 1707 1708 b += addr[5] << 8; 1709 b += addr[4]; 1710 a += addr[3] << 24; 1711 a += addr[2] << 16; 1712 a += addr[1] << 8; 1713 a += addr[0]; 1714 1715 mix(a, b, c); 1716 1717 return c; 1718 } 1719 #undef mix 1720