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