sys/net80211/ieee80211.c

   1 /*-
   2  * Copyright (c) 2001 Atsushi Onoe
   3  * Copyright (c) 2002-2005 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  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * Alternatively, this software may be distributed under the terms of the
  18  * GNU General Public License ("GPL") version 2 as published by the Free
  19  * Software Foundation.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 /*
  37  * IEEE 802.11 generic handler
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/kernel.h>
  43
  44 #include <sys/socket.h>
  45
  46 #include <net/if.h>
  47 #include <net/if_media.h>
  48 #include <net/ethernet.h>
  49
  50 #include <net80211/ieee80211_var.h>
  51
  52 #include <net/bpf.h>
  53
  54 const char *ieee80211_phymode_name[] = {
  55         "auto",         /* IEEE80211_MODE_AUTO */
  56         "11a",          /* IEEE80211_MODE_11A */
  57         "11b",          /* IEEE80211_MODE_11B */
  58         "11g",          /* IEEE80211_MODE_11G */
  59         "FH",           /* IEEE80211_MODE_FH */
  60         "turboA",       /* IEEE80211_MODE_TURBO_A */
  61         "turboG",       /* IEEE80211_MODE_TURBO_G */
  62 };
  63
  64 /*
  65  * Default supported rates for 802.11 operation (in IEEE .5Mb units).
  66  */
  67 #define B(r)    ((r) | IEEE80211_RATE_BASIC)
  68 static const struct ieee80211_rateset ieee80211_rateset_11a =
  69         { 8, { B(12), 18, B(24), 36, B(48), 72, 96, 108 } };
  70 static const struct ieee80211_rateset ieee80211_rateset_half =
  71         { 8, { B(6), 9, B(12), 18, B(24), 36, 48, 54 } };
  72 static const struct ieee80211_rateset ieee80211_rateset_quarter =
  73         { 8, { B(3), 4, B(6), 9, B(12), 18, 24, 27 } };
  74 static const struct ieee80211_rateset ieee80211_rateset_11b =
  75         { 4, { B(2), B(4), B(11), B(22) } };
  76 /* NB: OFDM rates are handled specially based on mode */
  77 static const struct ieee80211_rateset ieee80211_rateset_11g =
  78         { 12, { B(2), B(4), B(11), B(22), 12, 18, 24, 36, 48, 72, 96, 108 } };
  79 #undef B
  80
  81 /* list of all instances */
  82 SLIST_HEAD(ieee80211_list, ieee80211com);
  83 static struct ieee80211_list ieee80211_list =
  84         SLIST_HEAD_INITIALIZER(ieee80211_list);
  85 static u_int8_t ieee80211_vapmap[32];           /* enough for 256 */
  86 static struct mtx ieee80211_vap_mtx;
  87 MTX_SYSINIT(ieee80211, &ieee80211_vap_mtx, "net80211 instances", MTX_DEF);
  88
  89 static void
  90 ieee80211_add_vap(struct ieee80211com *ic)
  91 {
  92 #define N(a)    (sizeof(a)/sizeof(a[0]))
  93         int i;
  94         u_int8_t b;
  95
  96         mtx_lock(&ieee80211_vap_mtx);
  97         ic->ic_vap = 0;
  98         for (i = 0; i < N(ieee80211_vapmap) && ieee80211_vapmap[i] == 0xff; i++)
  99                 ic->ic_vap += NBBY;
 100         if (i == N(ieee80211_vapmap))
 101                 panic("vap table full");
 102         for (b = ieee80211_vapmap[i]; b & 1; b >>= 1)
 103                 ic->ic_vap++;
 104         setbit(ieee80211_vapmap, ic->ic_vap);
 105         SLIST_INSERT_HEAD(&ieee80211_list, ic, ic_next);
 106         mtx_unlock(&ieee80211_vap_mtx);
 107 #undef N
 108 }
 109
 110 static void
 111 ieee80211_remove_vap(struct ieee80211com *ic)
 112 {
 113         mtx_lock(&ieee80211_vap_mtx);
 114         SLIST_REMOVE(&ieee80211_list, ic, ieee80211com, ic_next);
 115         KASSERT(ic->ic_vap < sizeof(ieee80211_vapmap)*NBBY,
 116                 ("invalid vap id %d", ic->ic_vap));
 117         KASSERT(isset(ieee80211_vapmap, ic->ic_vap),
 118                 ("vap id %d not allocated", ic->ic_vap));
 119         clrbit(ieee80211_vapmap, ic->ic_vap);
 120         mtx_unlock(&ieee80211_vap_mtx);
 121 }
 122
 123 /*
 124  * Default reset method for use with the ioctl support.  This
 125  * method is invoked after any state change in the 802.11
 126  * layer that should be propagated to the hardware but not
 127  * require re-initialization of the 802.11 state machine (e.g
 128  * rescanning for an ap).  We always return ENETRESET which
 129  * should cause the driver to re-initialize the device. Drivers
 130  * can override this method to implement more optimized support.
 131  */
 132 static int
 133 ieee80211_default_reset(struct ifnet *ifp)
 134 {
 135         return ENETRESET;
 136 }
 137
 138 /*
 139  * Fill in 802.11 available channel set, mark
 140  * all available channels as active, and pick
 141  * a default channel if not already specified.
 142  */
 143 static void
 144 ieee80211_chan_init(struct ieee80211com *ic)
 145 {
 146 #define DEFAULTRATES(m, def) do { \
 147         if (isset(ic->ic_modecaps, m) && ic->ic_sup_rates[m].rs_nrates == 0) \
 148                 ic->ic_sup_rates[m] = def; \
 149 } while (0)
 150         struct ifnet *ifp = ic->ic_ifp;
 151         struct ieee80211_channel *c;
 152         int i;
 153
 154         memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail));
 155         setbit(ic->ic_modecaps, IEEE80211_MODE_AUTO);
 156         for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
 157                 c = &ic->ic_channels[i];
 158                 if (c->ic_flags) {
 159                         /*
 160                          * Verify driver passed us valid data.
 161                          */
 162                         if (i != ieee80211_chan2ieee(ic, c)) {
 163                                 if_printf(ifp, "bad channel ignored; "
 164                                         "freq %u flags %x number %u\n",
 165                                         c->ic_freq, c->ic_flags, i);
 166                                 c->ic_flags = 0;        /* NB: remove */
 167                                 continue;
 168                         }
 169                         setbit(ic->ic_chan_avail, i);
 170                         /*
 171                          * Identify mode capabilities.
 172                          */
 173                         if (IEEE80211_IS_CHAN_A(c))
 174                                 setbit(ic->ic_modecaps, IEEE80211_MODE_11A);
 175                         if (IEEE80211_IS_CHAN_B(c))
 176                                 setbit(ic->ic_modecaps, IEEE80211_MODE_11B);
 177                         if (IEEE80211_IS_CHAN_ANYG(c))
 178                                 setbit(ic->ic_modecaps, IEEE80211_MODE_11G);
 179                         if (IEEE80211_IS_CHAN_FHSS(c))
 180                                 setbit(ic->ic_modecaps, IEEE80211_MODE_FH);
 181                         if (IEEE80211_IS_CHAN_T(c))
 182                                 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_A);
 183                         if (IEEE80211_IS_CHAN_108G(c))
 184                                 setbit(ic->ic_modecaps, IEEE80211_MODE_TURBO_G);
 185                         if (ic->ic_curchan == NULL) {
 186                                 /* arbitrarily pick the first channel */
 187                                 ic->ic_curchan = &ic->ic_channels[i];
 188                         }
 189                 }
 190         }
 191
 192         /* fillin well-known rate sets if driver has not specified */
 193         DEFAULTRATES(IEEE80211_MODE_11B,         ieee80211_rateset_11b);
 194         DEFAULTRATES(IEEE80211_MODE_11G,         ieee80211_rateset_11g);
 195         DEFAULTRATES(IEEE80211_MODE_11A,         ieee80211_rateset_11a);
 196         DEFAULTRATES(IEEE80211_MODE_TURBO_A,     ieee80211_rateset_11a);
 197         DEFAULTRATES(IEEE80211_MODE_TURBO_G,     ieee80211_rateset_11g);
 198
 199         /*
 200          * Set auto mode to reset active channel state and any desired channel.
 201          */
 202         (void) ieee80211_setmode(ic, IEEE80211_MODE_AUTO);
 203 #undef DEFAULTRATES
 204 }
 205
 206 void
 207 ieee80211_ifattach(struct ieee80211com *ic)
 208 {
 209         struct ifnet *ifp = ic->ic_ifp;
 210
 211         ether_ifattach(ifp, ic->ic_myaddr);
 212         ifp->if_output = ieee80211_output;
 213
 214         bpfattach2(ifp, DLT_IEEE802_11,
 215             sizeof(struct ieee80211_frame_addr4), &ic->ic_rawbpf);
 216
 217         ieee80211_crypto_attach(ic);
 218
 219         ic->ic_des_chan = IEEE80211_CHAN_ANYC;
 220         /*
 221          * Fill in 802.11 available channel set, mark all
 222          * available channels as active, and pick a default
 223          * channel if not already specified.
 224          */
 225         ieee80211_chan_init(ic);
 226 #if 0
 227         /*
 228          * Enable WME by default if we're capable.
 229          */
 230         if (ic->ic_caps & IEEE80211_C_WME)
 231                 ic->ic_flags |= IEEE80211_F_WME;
 232 #endif
 233         if (ic->ic_caps & IEEE80211_C_BURST)
 234                 ic->ic_flags |= IEEE80211_F_BURST;
 235
 236         ic->ic_bintval = IEEE80211_BINTVAL_DEFAULT;
 237         ic->ic_bmissthreshold = IEEE80211_HWBMISS_DEFAULT;
 238         ic->ic_dtim_period = IEEE80211_DTIM_DEFAULT;
 239         IEEE80211_BEACON_LOCK_INIT(ic, "beacon");
 240
 241         ic->ic_lintval = ic->ic_bintval;
 242         ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX;
 243
 244         ieee80211_node_attach(ic);
 245         ieee80211_proto_attach(ic);
 246
 247         ieee80211_add_vap(ic);
 248
 249         ieee80211_sysctl_attach(ic);            /* NB: requires ic_vap */
 250
 251         /*
 252          * Install a default reset method for the ioctl support.
 253          * The driver is expected to fill this in before calling us.
 254          */
 255         if (ic->ic_reset == NULL)
 256                 ic->ic_reset = ieee80211_default_reset;
 257
 258         KASSERT(ifp->if_spare2 == NULL, ("oops, hosed"));
 259         ifp->if_spare2 = ic;                    /* XXX temp backpointer */
 260 }
 261
 262 void
 263 ieee80211_ifdetach(struct ieee80211com *ic)
 264 {
 265         struct ifnet *ifp = ic->ic_ifp;
 266
 267         ieee80211_remove_vap(ic);
 268
 269         ieee80211_sysctl_detach(ic);
 270         /* NB: must be called before ieee80211_node_detach */
 271         ieee80211_proto_detach(ic);
 272         ieee80211_crypto_detach(ic);
 273         ieee80211_node_detach(ic);
 274         ifmedia_removeall(&ic->ic_media);
 275
 276         IEEE80211_BEACON_LOCK_DESTROY(ic);
 277
 278         bpfdetach(ifp);
 279         ether_ifdetach(ifp);
 280 }
 281
 282 static __inline int
 283 mapgsm(u_int freq, u_int flags)
 284 {
 285         freq *= 10;
 286         if (flags & IEEE80211_CHAN_QUARTER)
 287                 freq += 5;
 288         else if (flags & IEEE80211_CHAN_HALF)
 289                 freq += 10;
 290         else
 291                 freq += 20;
 292         /* NB: there is no 907/20 wide but leave room */
 293         return (freq - 906*10) / 5;
 294 }
 295
 296 static __inline int
 297 mappsb(u_int freq, u_int flags)
 298 {
 299         return 37 + ((freq * 10) + ((freq % 5) == 2 ? 5 : 0) - 49400) / 5;
 300 }
 301
 302 /*
 303  * Convert MHz frequency to IEEE channel number.
 304  */
 305 int
 306 ieee80211_mhz2ieee(u_int freq, u_int flags)
 307 {
 308 #define IS_FREQ_IN_PSB(_freq) ((_freq) > 4940 && (_freq) < 4990)
 309         if (flags & IEEE80211_CHAN_GSM)
 310                 return mapgsm(freq, flags);
 311         if (flags & IEEE80211_CHAN_2GHZ) {      /* 2GHz band */
 312                 if (freq == 2484)
 313                         return 14;
 314                 if (freq < 2484)
 315                         return ((int) freq - 2407) / 5;
 316                 else
 317                         return 15 + ((freq - 2512) / 20);
 318         } else if (flags & IEEE80211_CHAN_5GHZ) {       /* 5Ghz band */
 319                 if (freq <= 5000) {
 320                         if (IS_FREQ_IN_PSB(freq))
 321                                 return mappsb(freq, flags);
 322                         return (freq - 4000) / 5;
 323                 } else
 324                         return (freq - 5000) / 5;
 325         } else {                                /* either, guess */
 326                 if (freq == 2484)
 327                         return 14;
 328                 if (freq < 2484) {
 329                         if (907 <= freq && freq <= 922)
 330                                 return mapgsm(freq, flags);
 331                         return ((int) freq - 2407) / 5;
 332                 }
 333                 if (freq < 5000) {
 334                         if (IS_FREQ_IN_PSB(freq))
 335                                 return mappsb(freq, flags);
 336                         else if (freq > 4900)
 337                                 return (freq - 4000) / 5;
 338                         else
 339                                 return 15 + ((freq - 2512) / 20);
 340                 }
 341                 return (freq - 5000) / 5;
 342         }
 343 #undef IS_FREQ_IN_PSB
 344 }
 345
 346 /*
 347  * Convert channel to IEEE channel number.
 348  */
 349 int
 350 ieee80211_chan2ieee(struct ieee80211com *ic, const struct ieee80211_channel *c)
 351 {
 352         if (ic->ic_channels <= c && c <= &ic->ic_channels[IEEE80211_CHAN_MAX])
 353                 return c - ic->ic_channels;
 354         else if (c == IEEE80211_CHAN_ANYC)
 355                 return IEEE80211_CHAN_ANY;
 356         else if (c != NULL) {
 357                 if_printf(ic->ic_ifp, "invalid channel freq %u flags %x\n",
 358                         c->ic_freq, c->ic_flags);
 359                 return 0;               /* XXX */
 360         } else {
 361                 if_printf(ic->ic_ifp, "invalid channel (NULL)\n");
 362                 return 0;               /* XXX */
 363         }
 364 }
 365
 366 /*
 367  * Convert IEEE channel number to MHz frequency.
 368  */
 369 u_int
 370 ieee80211_ieee2mhz(u_int chan, u_int flags)
 371 {
 372         if (flags & IEEE80211_CHAN_GSM)
 373                 return 907 + 5 * (chan / 10);
 374         if (flags & IEEE80211_CHAN_2GHZ) {      /* 2GHz band */
 375                 if (chan == 14)
 376                         return 2484;
 377                 if (chan < 14)
 378                         return 2407 + chan*5;
 379                 else
 380                         return 2512 + ((chan-15)*20);
 381         } else if (flags & IEEE80211_CHAN_5GHZ) {/* 5Ghz band */
 382                 if (flags & (IEEE80211_CHAN_HALF|IEEE80211_CHAN_QUARTER)) {
 383                         chan -= 37;
 384                         return 4940 + chan*5 + (chan % 5 ? 2 : 0);
 385                 }
 386                 return 5000 + (chan*5);
 387         } else {                                /* either, guess */
 388                 /* XXX can't distinguish PSB+GSM channels */
 389                 if (chan == 14)
 390                         return 2484;
 391                 if (chan < 14)                  /* 0-13 */
 392                         return 2407 + chan*5;
 393                 if (chan < 27)                  /* 15-26 */
 394                         return 2512 + ((chan-15)*20);
 395                 return 5000 + (chan*5);
 396         }
 397 }
 398
 399 /*
 400  * Setup the media data structures according to the channel and
 401  * rate tables.  This must be called by the driver after
 402  * ieee80211_attach and before most anything else.
 403  */
 404 void
 405 ieee80211_media_init(struct ieee80211com *ic,
 406         ifm_change_cb_t media_change, ifm_stat_cb_t media_stat)
 407 {
 408 #define ADD(_ic, _s, _o) \
 409         ifmedia_add(&(_ic)->ic_media, \
 410                 IFM_MAKEWORD(IFM_IEEE80211, (_s), (_o), 0), 0, NULL)
 411         struct ifnet *ifp = ic->ic_ifp;
 412         struct ifmediareq imr;
 413         int i, j, mode, rate, maxrate, mword, mopt, r;
 414         struct ieee80211_rateset *rs;
 415         struct ieee80211_rateset allrates;
 416
 417         /* NB: this works because the structure is initialized to zero */
 418         if (LIST_EMPTY(&ic->ic_media.ifm_list)) {
 419                 /*
 420                  * Do late attach work that must wait for any subclass
 421                  * (i.e. driver) work such as overriding methods.
 422                  */
 423                 ieee80211_node_lateattach(ic);
 424         } else {
 425                 /*
 426                  * We are re-initializing the channel list; clear
 427                  * the existing media state as the media routines
 428                  * don't suppress duplicates.
 429                  */
 430                 ifmedia_removeall(&ic->ic_media);
 431                 ieee80211_chan_init(ic);
 432         }
 433
 434         /*
 435          * Fill in media characteristics.
 436          */
 437         ifmedia_init(&ic->ic_media, 0, media_change, media_stat);
 438         maxrate = 0;
 439         memset(&allrates, 0, sizeof(allrates));
 440         for (mode = IEEE80211_MODE_AUTO; mode < IEEE80211_MODE_MAX; mode++) {
 441                 static const u_int mopts[] = {
 442                         IFM_AUTO,
 443                         IFM_IEEE80211_11A,
 444                         IFM_IEEE80211_11B,
 445                         IFM_IEEE80211_11G,
 446                         IFM_IEEE80211_FH,
 447                         IFM_IEEE80211_11A | IFM_IEEE80211_TURBO,
 448                         IFM_IEEE80211_11G | IFM_IEEE80211_TURBO,
 449                 };
 450                 if (isclr(ic->ic_modecaps, mode))
 451                         continue;
 452                 mopt = mopts[mode];
 453                 ADD(ic, IFM_AUTO, mopt);        /* e.g. 11a auto */
 454                 if (ic->ic_caps & IEEE80211_C_IBSS)
 455                         ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_ADHOC);
 456                 if (ic->ic_caps & IEEE80211_C_HOSTAP)
 457                         ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_HOSTAP);
 458                 if (ic->ic_caps & IEEE80211_C_AHDEMO)
 459                         ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0);
 460                 if (ic->ic_caps & IEEE80211_C_MONITOR)
 461                         ADD(ic, IFM_AUTO, mopt | IFM_IEEE80211_MONITOR);
 462                 if (mode == IEEE80211_MODE_AUTO)
 463                         continue;
 464                 rs = &ic->ic_sup_rates[mode];
 465                 for (i = 0; i < rs->rs_nrates; i++) {
 466                         rate = rs->rs_rates[i];
 467                         mword = ieee80211_rate2media(ic, rate, mode);
 468                         if (mword == 0)
 469                                 continue;
 470                         ADD(ic, mword, mopt);
 471                         if (ic->ic_caps & IEEE80211_C_IBSS)
 472                                 ADD(ic, mword, mopt | IFM_IEEE80211_ADHOC);
 473                         if (ic->ic_caps & IEEE80211_C_HOSTAP)
 474                                 ADD(ic, mword, mopt | IFM_IEEE80211_HOSTAP);
 475                         if (ic->ic_caps & IEEE80211_C_AHDEMO)
 476                                 ADD(ic, mword, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0);
 477                         if (ic->ic_caps & IEEE80211_C_MONITOR)
 478                                 ADD(ic, mword, mopt | IFM_IEEE80211_MONITOR);
 479                         /*
 480                          * Add rate to the collection of all rates.
 481                          */
 482                         r = rate & IEEE80211_RATE_VAL;
 483                         for (j = 0; j < allrates.rs_nrates; j++)
 484                                 if (allrates.rs_rates[j] == r)
 485                                         break;
 486                         if (j == allrates.rs_nrates) {
 487                                 /* unique, add to the set */
 488                                 allrates.rs_rates[j] = r;
 489                                 allrates.rs_nrates++;
 490                         }
 491                         rate = (rate & IEEE80211_RATE_VAL) / 2;
 492                         if (rate > maxrate)
 493                                 maxrate = rate;
 494                 }
 495         }
 496         for (i = 0; i < allrates.rs_nrates; i++) {
 497                 mword = ieee80211_rate2media(ic, allrates.rs_rates[i],
 498                                 IEEE80211_MODE_AUTO);
 499                 if (mword == 0)
 500                         continue;
 501                 mword = IFM_SUBTYPE(mword);     /* remove media options */
 502                 ADD(ic, mword, 0);
 503                 if (ic->ic_caps & IEEE80211_C_IBSS)
 504                         ADD(ic, mword, IFM_IEEE80211_ADHOC);
 505                 if (ic->ic_caps & IEEE80211_C_HOSTAP)
 506                         ADD(ic, mword, IFM_IEEE80211_HOSTAP);
 507                 if (ic->ic_caps & IEEE80211_C_AHDEMO)
 508                         ADD(ic, mword, IFM_IEEE80211_ADHOC | IFM_FLAG0);
 509                 if (ic->ic_caps & IEEE80211_C_MONITOR)
 510                         ADD(ic, mword, IFM_IEEE80211_MONITOR);
 511         }
 512         ieee80211_media_status(ifp, &imr);
 513         ifmedia_set(&ic->ic_media, imr.ifm_active);
 514
 515         if (maxrate)
 516                 ifp->if_baudrate = IF_Mbps(maxrate);
 517 #undef ADD
 518 }
 519
 520 const struct ieee80211_rateset *
 521 ieee80211_get_suprates(struct ieee80211com *ic, const struct ieee80211_channel *c)
 522 {
 523         enum ieee80211_phymode mode = ieee80211_chan2mode(ic, c);
 524
 525         if (IEEE80211_IS_CHAN_HALF(c))
 526                 return &ieee80211_rateset_half;
 527         if (IEEE80211_IS_CHAN_QUARTER(c))
 528                 return &ieee80211_rateset_quarter;
 529         return &ic->ic_sup_rates[mode];
 530 }
 531
 532 void
 533 ieee80211_announce(struct ieee80211com *ic)
 534 {
 535         struct ifnet *ifp = ic->ic_ifp;
 536         int i, mode, rate, mword;
 537         struct ieee80211_rateset *rs;
 538
 539         for (mode = IEEE80211_MODE_11A; mode < IEEE80211_MODE_MAX; mode++) {
 540                 if (isclr(ic->ic_modecaps, mode))
 541                         continue;
 542                 if_printf(ifp, "%s rates: ", ieee80211_phymode_name[mode]);
 543                 rs = &ic->ic_sup_rates[mode];
 544                 for (i = 0; i < rs->rs_nrates; i++) {
 545                         rate = rs->rs_rates[i];
 546                         mword = ieee80211_rate2media(ic, rate, mode);
 547                         if (mword == 0)
 548                                 continue;
 549                         printf("%s%d%sMbps", (i != 0 ? " " : ""),
 550                             (rate & IEEE80211_RATE_VAL) / 2,
 551                             ((rate & 0x1) != 0 ? ".5" : ""));
 552                 }
 553                 printf("\n");
 554         }
 555 }
 556
 557 static int
 558 findrate(struct ieee80211com *ic, enum ieee80211_phymode mode, int rate)
 559 {
 560 #define IEEERATE(_ic,_m,_i) \
 561         ((_ic)->ic_sup_rates[_m].rs_rates[_i] & IEEE80211_RATE_VAL)
 562         int i, nrates = ic->ic_sup_rates[mode].rs_nrates;
 563         for (i = 0; i < nrates; i++)
 564                 if (IEEERATE(ic, mode, i) == rate)
 565                         return i;
 566         return -1;
 567 #undef IEEERATE
 568 }
 569
 570 /*
 571  * Find an instance by it's mac address.
 572  */
 573 struct ieee80211com *
 574 ieee80211_find_vap(const u_int8_t mac[IEEE80211_ADDR_LEN])
 575 {
 576         struct ieee80211com *ic;
 577
 578         /* XXX lock */
 579         SLIST_FOREACH(ic, &ieee80211_list, ic_next)
 580                 if (IEEE80211_ADDR_EQ(mac, ic->ic_myaddr))
 581                         return ic;
 582         return NULL;
 583 }
 584
 585 static struct ieee80211com *
 586 ieee80211_find_instance(struct ifnet *ifp)
 587 {
 588         struct ieee80211com *ic;
 589
 590         /* XXX lock */
 591         /* XXX not right for multiple instances but works for now */
 592         SLIST_FOREACH(ic, &ieee80211_list, ic_next)
 593                 if (ic->ic_ifp == ifp)
 594                         return ic;
 595         return NULL;
 596 }
 597
 598 /*
 599  * Handle a media change request.
 600  */
 601 int
 602 ieee80211_media_change(struct ifnet *ifp)
 603 {
 604         struct ieee80211com *ic;
 605         struct ifmedia_entry *ime;
 606         enum ieee80211_opmode newopmode;
 607         enum ieee80211_phymode newphymode;
 608         int i, j, newrate, error = 0;
 609
 610         ic = ieee80211_find_instance(ifp);
 611         if (!ic) {
 612                 if_printf(ifp, "%s: no 802.11 instance!\n", __func__);
 613                 return EINVAL;
 614         }
 615         ime = ic->ic_media.ifm_cur;
 616         /*
 617          * First, identify the phy mode.
 618          */
 619         switch (IFM_MODE(ime->ifm_media)) {
 620         case IFM_IEEE80211_11A:
 621                 newphymode = IEEE80211_MODE_11A;
 622                 break;
 623         case IFM_IEEE80211_11B:
 624                 newphymode = IEEE80211_MODE_11B;
 625                 break;
 626         case IFM_IEEE80211_11G:
 627                 newphymode = IEEE80211_MODE_11G;
 628                 break;
 629         case IFM_IEEE80211_FH:
 630                 newphymode = IEEE80211_MODE_FH;
 631                 break;
 632         case IFM_AUTO:
 633                 newphymode = IEEE80211_MODE_AUTO;
 634                 break;
 635         default:
 636                 return EINVAL;
 637         }
 638         /*
 639          * Turbo mode is an ``option''.
 640          * XXX does not apply to AUTO
 641          */
 642         if (ime->ifm_media & IFM_IEEE80211_TURBO) {
 643                 if (newphymode == IEEE80211_MODE_11A)
 644                         newphymode = IEEE80211_MODE_TURBO_A;
 645                 else if (newphymode == IEEE80211_MODE_11G)
 646                         newphymode = IEEE80211_MODE_TURBO_G;
 647                 else
 648                         return EINVAL;
 649         }
 650         /*
 651          * Validate requested mode is available.
 652          */
 653         if (isclr(ic->ic_modecaps, newphymode))
 654                 return EINVAL;
 655
 656         /*
 657          * Next, the fixed/variable rate.
 658          */
 659         i = -1;
 660         if (IFM_SUBTYPE(ime->ifm_media) != IFM_AUTO) {
 661                 /*
 662                  * Convert media subtype to rate.
 663                  */
 664                 newrate = ieee80211_media2rate(ime->ifm_media);
 665                 if (newrate == 0)
 666                         return EINVAL;
 667                 /*
 668                  * Check the rate table for the specified/current phy.
 669                  */
 670                 if (newphymode == IEEE80211_MODE_AUTO) {
 671                         /*
 672                          * In autoselect mode search for the rate.
 673                          */
 674                         for (j = IEEE80211_MODE_11A;
 675                              j < IEEE80211_MODE_MAX; j++) {
 676                                 if (isclr(ic->ic_modecaps, j))
 677                                         continue;
 678                                 i = findrate(ic, j, newrate);
 679                                 if (i != -1) {
 680                                         /* lock mode too */
 681                                         newphymode = j;
 682                                         break;
 683                                 }
 684                         }
 685                 } else {
 686                         i = findrate(ic, newphymode, newrate);
 687                 }
 688                 if (i == -1)                    /* mode/rate mismatch */
 689                         return EINVAL;
 690         }
 691         /* NB: defer rate setting to later */
 692
 693         /*
 694          * Deduce new operating mode but don't install it just yet.
 695          */
 696         if ((ime->ifm_media & (IFM_IEEE80211_ADHOC|IFM_FLAG0)) ==
 697             (IFM_IEEE80211_ADHOC|IFM_FLAG0))
 698                 newopmode = IEEE80211_M_AHDEMO;
 699         else if (ime->ifm_media & IFM_IEEE80211_HOSTAP)
 700                 newopmode = IEEE80211_M_HOSTAP;
 701         else if (ime->ifm_media & IFM_IEEE80211_ADHOC)
 702                 newopmode = IEEE80211_M_IBSS;
 703         else if (ime->ifm_media & IFM_IEEE80211_MONITOR)
 704                 newopmode = IEEE80211_M_MONITOR;
 705         else
 706                 newopmode = IEEE80211_M_STA;
 707
 708         /*
 709          * Autoselect doesn't make sense when operating as an AP.
 710          * If no phy mode has been selected, pick one and lock it
 711          * down so rate tables can be used in forming beacon frames
 712          * and the like.
 713          */
 714         if (newopmode == IEEE80211_M_HOSTAP &&
 715             newphymode == IEEE80211_MODE_AUTO) {
 716                 for (j = IEEE80211_MODE_11A; j < IEEE80211_MODE_MAX; j++)
 717                         if (isset(ic->ic_modecaps, j)) {
 718                                 newphymode = j;
 719                                 break;
 720                         }
 721         }
 722
 723         /*
 724          * Handle phy mode change.
 725          */
 726         if (ic->ic_curmode != newphymode) {             /* change phy mode */
 727                 error = ieee80211_setmode(ic, newphymode);
 728                 if (error != 0)
 729                         return error;
 730                 error = ENETRESET;
 731         }
 732
 733         /*
 734          * Committed to changes, install the rate setting.
 735          */
 736         if (ic->ic_fixed_rate != i) {
 737                 ic->ic_fixed_rate = i;                  /* set fixed tx rate */
 738                 error = ENETRESET;
 739         }
 740
 741         /*
 742          * Handle operating mode change.
 743          */
 744         if (ic->ic_opmode != newopmode) {
 745                 ic->ic_opmode = newopmode;
 746                 switch (newopmode) {
 747                 case IEEE80211_M_AHDEMO:
 748                 case IEEE80211_M_HOSTAP:
 749                 case IEEE80211_M_STA:
 750                 case IEEE80211_M_MONITOR:
 751                         ic->ic_flags &= ~IEEE80211_F_IBSSON;
 752                         break;
 753                 case IEEE80211_M_IBSS:
 754                         ic->ic_flags |= IEEE80211_F_IBSSON;
 755                         break;
 756                 }
 757                 /*
 758                  * Yech, slot time may change depending on the
 759                  * operating mode so reset it to be sure everything
 760                  * is setup appropriately.
 761                  */
 762                 ieee80211_reset_erp(ic);
 763                 ieee80211_wme_initparams(ic);   /* after opmode change */
 764                 error = ENETRESET;
 765         }
 766 #ifdef notdef
 767         if (error == 0)
 768                 ifp->if_baudrate = ifmedia_baudrate(ime->ifm_media);
 769 #endif
 770         return error;
 771 }
 772
 773 void
 774 ieee80211_media_status(struct ifnet *ifp, struct ifmediareq *imr)
 775 {
 776         struct ieee80211com *ic;
 777         const struct ieee80211_rateset *rs;
 778
 779         ic = ieee80211_find_instance(ifp);
 780         if (!ic) {
 781                 if_printf(ifp, "%s: no 802.11 instance!\n", __func__);
 782                 return;
 783         }
 784         imr->ifm_status = IFM_AVALID;
 785         imr->ifm_active = IFM_IEEE80211;
 786         if (ic->ic_state == IEEE80211_S_RUN)
 787                 imr->ifm_status |= IFM_ACTIVE;
 788         /*
 789          * Calculate a current rate if possible.
 790          */
 791         if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE) {
 792                 /*
 793                  * A fixed rate is set, report that.
 794                  */
 795                 rs = ieee80211_get_suprates(ic, ic->ic_curchan);
 796                 imr->ifm_active |= ieee80211_rate2media(ic,
 797                         rs->rs_rates[ic->ic_fixed_rate], ic->ic_curmode);
 798         } else if (ic->ic_opmode == IEEE80211_M_STA) {
 799                 /*
 800                  * In station mode report the current transmit rate.
 801                  */
 802                 rs = &ic->ic_bss->ni_rates;
 803                 imr->ifm_active |= ieee80211_rate2media(ic,
 804                         rs->rs_rates[ic->ic_bss->ni_txrate], ic->ic_curmode);
 805         } else
 806                 imr->ifm_active |= IFM_AUTO;
 807         switch (ic->ic_opmode) {
 808         case IEEE80211_M_STA:
 809                 break;
 810         case IEEE80211_M_IBSS:
 811                 imr->ifm_active |= IFM_IEEE80211_ADHOC;
 812                 break;
 813         case IEEE80211_M_AHDEMO:
 814                 /* should not come here */
 815                 break;
 816         case IEEE80211_M_HOSTAP:
 817                 imr->ifm_active |= IFM_IEEE80211_HOSTAP;
 818                 break;
 819         case IEEE80211_M_MONITOR:
 820                 imr->ifm_active |= IFM_IEEE80211_MONITOR;
 821                 break;
 822         }
 823         switch (ic->ic_curmode) {
 824         case IEEE80211_MODE_11A:
 825                 imr->ifm_active |= IFM_IEEE80211_11A;
 826                 break;
 827         case IEEE80211_MODE_11B:
 828                 imr->ifm_active |= IFM_IEEE80211_11B;
 829                 break;
 830         case IEEE80211_MODE_11G:
 831                 imr->ifm_active |= IFM_IEEE80211_11G;
 832                 break;
 833         case IEEE80211_MODE_FH:
 834                 imr->ifm_active |= IFM_IEEE80211_FH;
 835                 break;
 836         case IEEE80211_MODE_TURBO_A:
 837                 imr->ifm_active |= IFM_IEEE80211_11A
 838                                 |  IFM_IEEE80211_TURBO;
 839                 break;
 840         case IEEE80211_MODE_TURBO_G:
 841                 imr->ifm_active |= IFM_IEEE80211_11G
 842                                 |  IFM_IEEE80211_TURBO;
 843                 break;
 844         }
 845 }
 846
 847 void
 848 ieee80211_watchdog(struct ieee80211com *ic)
 849 {
 850         struct ieee80211_node_table *nt;
 851         int need_inact_timer = 0;
 852
 853         if (ic->ic_state != IEEE80211_S_INIT) {
 854                 if (ic->ic_mgt_timer && --ic->ic_mgt_timer == 0)
 855                         ieee80211_new_state(ic, IEEE80211_S_SCAN, 0);
 856                 nt = &ic->ic_scan;
 857                 if (nt->nt_inact_timer) {
 858                         if (--nt->nt_inact_timer == 0)
 859                                 nt->nt_timeout(nt);
 860                         need_inact_timer += nt->nt_inact_timer;
 861                 }
 862                 nt = &ic->ic_sta;
 863                 if (nt->nt_inact_timer) {
 864                         if (--nt->nt_inact_timer == 0)
 865                                 nt->nt_timeout(nt);
 866                         need_inact_timer += nt->nt_inact_timer;
 867                 }
 868         }
 869         if (ic->ic_mgt_timer != 0 || need_inact_timer)
 870                 ic->ic_ifp->if_timer = 1;
 871 }
 872
 873 /*
 874  * Set the current phy mode and recalculate the active channel
 875  * set based on the available channels for this mode.  Also
 876  * select a new default/current channel if the current one is
 877  * inappropriate for this mode.
 878  */
 879 int
 880 ieee80211_setmode(struct ieee80211com *ic, enum ieee80211_phymode mode)
 881 {
 882 #define N(a)    (sizeof(a) / sizeof(a[0]))
 883         static const u_int chanflags[] = {
 884                 0,                      /* IEEE80211_MODE_AUTO */
 885                 IEEE80211_CHAN_A,       /* IEEE80211_MODE_11A */
 886                 IEEE80211_CHAN_B,       /* IEEE80211_MODE_11B */
 887                 IEEE80211_CHAN_PUREG,   /* IEEE80211_MODE_11G */
 888                 IEEE80211_CHAN_FHSS,    /* IEEE80211_MODE_FH */
 889                 IEEE80211_CHAN_T,       /* IEEE80211_MODE_TURBO_A */
 890                 IEEE80211_CHAN_108G,    /* IEEE80211_MODE_TURBO_G */
 891         };
 892         struct ieee80211_channel *c;
 893         u_int modeflags;
 894         int i;
 895
 896         /* validate new mode */
 897         if (isclr(ic->ic_modecaps, mode)) {
 898                 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
 899                         "%s: mode %u not supported (caps 0x%x)\n",
 900                         __func__, mode, ic->ic_modecaps);
 901                 return EINVAL;
 902         }
 903
 904         /*
 905          * Verify at least one channel is present in the available
 906          * channel list before committing to the new mode.
 907          */
 908         KASSERT(mode < N(chanflags), ("Unexpected mode %u", mode));
 909         modeflags = chanflags[mode];
 910         for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
 911                 c = &ic->ic_channels[i];
 912                 if (c->ic_flags == 0)
 913                         continue;
 914                 if (mode == IEEE80211_MODE_AUTO) {
 915                         /* ignore static turbo channels for autoselect */
 916                         if (!IEEE80211_IS_CHAN_T(c))
 917                                 break;
 918                 } else {
 919                         if ((c->ic_flags & modeflags) == modeflags)
 920                                 break;
 921                 }
 922         }
 923         if (i > IEEE80211_CHAN_MAX) {
 924                 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
 925                         "%s: no channels found for mode %u\n", __func__, mode);
 926                 return EINVAL;
 927         }
 928
 929         /*
 930          * Calculate the active channel set.
 931          */
 932         memset(ic->ic_chan_active, 0, sizeof(ic->ic_chan_active));
 933         for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
 934                 c = &ic->ic_channels[i];
 935                 if (c->ic_flags == 0)
 936                         continue;
 937                 if (mode == IEEE80211_MODE_AUTO) {
 938                         /* take anything but static turbo channels */
 939                         if (!IEEE80211_IS_CHAN_T(c))
 940                                 setbit(ic->ic_chan_active, i);
 941                 } else {
 942                         if ((c->ic_flags & modeflags) == modeflags)
 943                                 setbit(ic->ic_chan_active, i);
 944                 }
 945         }
 946         /*
 947          * If no current/default channel is setup or the current
 948          * channel is wrong for the mode then pick the first
 949          * available channel from the active list.  This is likely
 950          * not the right one.
 951          */
 952         if (isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ic->ic_curchan))) {
 953                 ic->ic_curchan = NULL;
 954                 for (i = 0; i <= IEEE80211_CHAN_MAX; i++)
 955                         if (isset(ic->ic_chan_active, i)) {
 956                                 ic->ic_curchan = &ic->ic_channels[i];
 957                                 break;
 958                         }
 959                 KASSERT(ic->ic_curchan != NULL, ("no current channel"));
 960         }
 961         if (ic->ic_ibss_chan == NULL ||
 962             isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ic->ic_ibss_chan)))
 963                 ic->ic_ibss_chan = ic->ic_curchan;
 964         /*
 965          * If the desired channel is set but no longer valid then reset it.
 966          */
 967         if (ic->ic_des_chan != IEEE80211_CHAN_ANYC &&
 968             isclr(ic->ic_chan_active, ieee80211_chan2ieee(ic, ic->ic_des_chan)))
 969                 ic->ic_des_chan = IEEE80211_CHAN_ANYC;
 970
 971         /*
 972          * Adjust basic rates in 11b/11g supported rate set.
 973          * Note that if operating on a hal/quarter rate channel
 974          * this is a noop as those rates sets are different
 975          * and used instead.
 976          */
 977         if (mode == IEEE80211_MODE_11G || mode == IEEE80211_MODE_11B)
 978                 ieee80211_set11gbasicrates(&ic->ic_sup_rates[mode], mode);
 979
 980         /*
 981          * Setup an initial rate set according to the
 982          * current/default channel selected above.  This
 983          * will be changed when scanning but must exist
 984          * now so driver have a consistent state of ic_ibss_chan.
 985          */
 986         if (ic->ic_bss != NULL) /* NB: can be called before lateattach */
 987                 ic->ic_bss->ni_rates = ic->ic_sup_rates[mode];
 988
 989         ic->ic_curmode = mode;
 990         ieee80211_reset_erp(ic);        /* reset ERP state */
 991         ieee80211_wme_initparams(ic);   /* reset WME stat */
 992
 993         return 0;
 994 #undef N
 995 }
 996
 997 /*
 998  * Return the phy mode for with the specified channel so the
 999  * caller can select a rate set.  This is problematic for channels
1000  * where multiple operating modes are possible (e.g. 11g+11b).
1001  * In those cases we defer to the current operating mode when set.
1002  */
1003 enum ieee80211_phymode
1004 ieee80211_chan2mode(struct ieee80211com *ic, const struct ieee80211_channel *chan)
1005 {
1006         if (IEEE80211_IS_CHAN_T(chan)) {
1007                 return IEEE80211_MODE_TURBO_A;
1008         } else if (IEEE80211_IS_CHAN_5GHZ(chan)) {
1009                 return IEEE80211_MODE_11A;
1010         } else if (IEEE80211_IS_CHAN_FHSS(chan))
1011                 return IEEE80211_MODE_FH;
1012         else if (chan->ic_flags & (IEEE80211_CHAN_OFDM|IEEE80211_CHAN_DYN)) {
1013                 /*
1014                  * This assumes all 11g channels are also usable
1015                  * for 11b, which is currently true.
1016                  */
1017                 if (ic->ic_curmode == IEEE80211_MODE_TURBO_G)
1018                         return IEEE80211_MODE_TURBO_G;
1019                 if (ic->ic_curmode == IEEE80211_MODE_11B)
1020                         return IEEE80211_MODE_11B;
1021                 return IEEE80211_MODE_11G;
1022         } else
1023                 return IEEE80211_MODE_11B;
1024 }
1025
1026 /*
1027  * convert IEEE80211 rate value to ifmedia subtype.
1028  * ieee80211 rate is in unit of 0.5Mbps.
1029  */
1030 int
1031 ieee80211_rate2media(struct ieee80211com *ic, int rate, enum ieee80211_phymode mode)
1032 {
1033 #define N(a)    (sizeof(a) / sizeof(a[0]))
1034         static const struct {
1035                 u_int   m;      /* rate + mode */
1036                 u_int   r;      /* if_media rate */
1037         } rates[] = {
1038                 {   2 | IFM_IEEE80211_FH, IFM_IEEE80211_FH1 },
1039                 {   4 | IFM_IEEE80211_FH, IFM_IEEE80211_FH2 },
1040                 {   2 | IFM_IEEE80211_11B, IFM_IEEE80211_DS1 },
1041                 {   4 | IFM_IEEE80211_11B, IFM_IEEE80211_DS2 },
1042                 {  11 | IFM_IEEE80211_11B, IFM_IEEE80211_DS5 },
1043                 {  22 | IFM_IEEE80211_11B, IFM_IEEE80211_DS11 },
1044                 {  44 | IFM_IEEE80211_11B, IFM_IEEE80211_DS22 },
1045                 {  12 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM6 },
1046                 {  18 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM9 },
1047                 {  24 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM12 },
1048                 {  36 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM18 },
1049                 {  48 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM24 },
1050                 {  72 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM36 },
1051                 {  96 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM48 },
1052                 { 108 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM54 },
1053                 {   2 | IFM_IEEE80211_11G, IFM_IEEE80211_DS1 },
1054                 {   4 | IFM_IEEE80211_11G, IFM_IEEE80211_DS2 },
1055                 {  11 | IFM_IEEE80211_11G, IFM_IEEE80211_DS5 },
1056                 {  22 | IFM_IEEE80211_11G, IFM_IEEE80211_DS11 },
1057                 {  12 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM6 },
1058                 {  18 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM9 },
1059                 {  24 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM12 },
1060                 {  36 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM18 },
1061                 {  48 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM24 },
1062                 {  72 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM36 },
1063                 {  96 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM48 },
1064                 { 108 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM54 },
1065                 {   6 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM3 },
1066                 {   9 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM4 },
1067                 {  54 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM27 },
1068                 /* NB: OFDM72 doesn't realy exist so we don't handle it */
1069         };
1070         u_int mask, i;
1071
1072         mask = rate & IEEE80211_RATE_VAL;
1073         switch (mode) {
1074         case IEEE80211_MODE_11A:
1075         case IEEE80211_MODE_TURBO_A:
1076                 mask |= IFM_IEEE80211_11A;
1077                 break;
1078         case IEEE80211_MODE_11B:
1079                 mask |= IFM_IEEE80211_11B;
1080                 break;
1081         case IEEE80211_MODE_FH:
1082                 mask |= IFM_IEEE80211_FH;
1083                 break;
1084         case IEEE80211_MODE_AUTO:
1085                 /* NB: ic may be NULL for some drivers */
1086                 if (ic && ic->ic_phytype == IEEE80211_T_FH) {
1087                         mask |= IFM_IEEE80211_FH;
1088                         break;
1089                 }
1090                 /* NB: hack, 11g matches both 11b+11a rates */
1091                 /* fall thru... */
1092         case IEEE80211_MODE_11G:
1093         case IEEE80211_MODE_TURBO_G:
1094                 mask |= IFM_IEEE80211_11G;
1095                 break;
1096         }
1097         for (i = 0; i < N(rates); i++)
1098                 if (rates[i].m == mask)
1099                         return rates[i].r;
1100         return IFM_AUTO;
1101 #undef N
1102 }
1103
1104 int
1105 ieee80211_media2rate(int mword)
1106 {
1107 #define N(a)    (sizeof(a) / sizeof(a[0]))
1108         static const int ieeerates[] = {
1109                 -1,             /* IFM_AUTO */
1110                 0,              /* IFM_MANUAL */
1111                 0,              /* IFM_NONE */
1112                 2,              /* IFM_IEEE80211_FH1 */
1113                 4,              /* IFM_IEEE80211_FH2 */
1114                 2,              /* IFM_IEEE80211_DS1 */
1115                 4,              /* IFM_IEEE80211_DS2 */
1116                 11,             /* IFM_IEEE80211_DS5 */
1117                 22,             /* IFM_IEEE80211_DS11 */
1118                 44,             /* IFM_IEEE80211_DS22 */
1119                 12,             /* IFM_IEEE80211_OFDM6 */
1120                 18,             /* IFM_IEEE80211_OFDM9 */
1121                 24,             /* IFM_IEEE80211_OFDM12 */
1122                 36,             /* IFM_IEEE80211_OFDM18 */
1123                 48,             /* IFM_IEEE80211_OFDM24 */
1124                 72,             /* IFM_IEEE80211_OFDM36 */
1125                 96,             /* IFM_IEEE80211_OFDM48 */
1126                 108,            /* IFM_IEEE80211_OFDM54 */
1127                 144,            /* IFM_IEEE80211_OFDM72 */
1128                 0,              /* IFM_IEEE80211_DS354k */
1129                 0,              /* IFM_IEEE80211_DS512k */
1130                 6,              /* IFM_IEEE80211_OFDM3 */
1131                 9,              /* IFM_IEEE80211_OFDM4 */
1132                 54,             /* IFM_IEEE80211_OFDM27 */
1133         };
1134         return IFM_SUBTYPE(mword) < N(ieeerates) ?
1135                 ieeerates[IFM_SUBTYPE(mword)] : 0;
1136 #undef N
1137 }