sys/net80211/ieee80211_phy.c

   1 /*-
   2  * Copyright (c) 2007-2008 Sam Leffler, Errno Consulting
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 /*
  30  * IEEE 802.11 PHY-related support.
  31  */
  32
  33 #include "opt_inet.h"
  34
  35 #include <sys/param.h>
  36 #include <sys/kernel.h>
  37 #include <sys/systm.h>
  38
  39 #include <sys/socket.h>
  40
  41 #include <net/if.h>
  42 #include <net/if_media.h>
  43
  44 #include <net80211/ieee80211_var.h>
  45 #include <net80211/ieee80211_phy.h>
  46
  47 #ifdef notyet
  48 struct ieee80211_ds_plcp_hdr {
  49         uint8_t         i_signal;
  50         uint8_t         i_service;
  51         uint16_t        i_length;
  52         uint16_t        i_crc;
  53 } __packed;
  54
  55 #endif  /* notyet */
  56
  57 /* shorthands to compact tables for readability */
  58 #define OFDM    IEEE80211_T_OFDM
  59 #define CCK     IEEE80211_T_CCK
  60 #define TURBO   IEEE80211_T_TURBO
  61 #define HALF    IEEE80211_T_OFDM_HALF
  62 #define QUART   IEEE80211_T_OFDM_QUARTER
  63 #define PBCC    (IEEE80211_T_OFDM_QUARTER+1)            /* XXX */
  64 #define B(r)    (0x80 | r)
  65 #define Mb(x)   (x*1000)
  66
  67 static struct ieee80211_rate_table ieee80211_11b_table = {
  68     .rateCount = 4,             /* XXX no PBCC */
  69     .info = {
  70 /*                                   short            ctrl  */
  71 /*                                Preamble  dot11Rate Rate */
  72      [0] = { .phy = CCK,     1000,    0x00,      B(2),   0 },/*   1 Mb */
  73      [1] = { .phy = CCK,     2000,    0x04,      B(4),   1 },/*   2 Mb */
  74      [2] = { .phy = CCK,     5500,    0x04,     B(11),   1 },/* 5.5 Mb */
  75      [3] = { .phy = CCK,    11000,    0x04,     B(22),   1 },/*  11 Mb */
  76      [4] = { .phy = PBCC,   22000,    0x04,        44,   3 } /*  22 Mb */
  77     },
  78 };
  79
  80 static struct ieee80211_rate_table ieee80211_11g_table = {
  81     .rateCount = 12,
  82     .info = {
  83 /*                                   short            ctrl  */
  84 /*                                Preamble  dot11Rate Rate */
  85      [0] = { .phy = CCK,     1000,    0x00,      B(2),   0 },
  86      [1] = { .phy = CCK,     2000,    0x04,      B(4),   1 },
  87      [2] = { .phy = CCK,     5500,    0x04,     B(11),   2 },
  88      [3] = { .phy = CCK,    11000,    0x04,     B(22),   3 },
  89      [4] = { .phy = OFDM,    6000,    0x00,        12,   4 },
  90      [5] = { .phy = OFDM,    9000,    0x00,        18,   4 },
  91      [6] = { .phy = OFDM,   12000,    0x00,        24,   6 },
  92      [7] = { .phy = OFDM,   18000,    0x00,        36,   6 },
  93      [8] = { .phy = OFDM,   24000,    0x00,        48,   8 },
  94      [9] = { .phy = OFDM,   36000,    0x00,        72,   8 },
  95     [10] = { .phy = OFDM,   48000,    0x00,        96,   8 },
  96     [11] = { .phy = OFDM,   54000,    0x00,       108,   8 }
  97     },
  98 };
  99
 100 static struct ieee80211_rate_table ieee80211_11a_table = {
 101     .rateCount = 8,
 102     .info = {
 103 /*                                   short            ctrl  */
 104 /*                                Preamble  dot11Rate Rate */
 105      [0] = { .phy = OFDM,    6000,    0x00,     B(12),   0 },
 106      [1] = { .phy = OFDM,    9000,    0x00,        18,   0 },
 107      [2] = { .phy = OFDM,   12000,    0x00,     B(24),   2 },
 108      [3] = { .phy = OFDM,   18000,    0x00,        36,   2 },
 109      [4] = { .phy = OFDM,   24000,    0x00,     B(48),   4 },
 110      [5] = { .phy = OFDM,   36000,    0x00,        72,   4 },
 111      [6] = { .phy = OFDM,   48000,    0x00,        96,   4 },
 112      [7] = { .phy = OFDM,   54000,    0x00,       108,   4 }
 113     },
 114 };
 115
 116 static struct ieee80211_rate_table ieee80211_half_table = {
 117     .rateCount = 8,
 118     .info = {
 119 /*                                   short            ctrl  */
 120 /*                                Preamble  dot11Rate Rate */
 121      [0] = { .phy = HALF,    3000,    0x00,      B(6),   0 },
 122      [1] = { .phy = HALF,    4500,    0x00,         9,   0 },
 123      [2] = { .phy = HALF,    6000,    0x00,     B(12),   2 },
 124      [3] = { .phy = HALF,    9000,    0x00,        18,   2 },
 125      [4] = { .phy = HALF,   12000,    0x00,     B(24),   4 },
 126      [5] = { .phy = HALF,   18000,    0x00,        36,   4 },
 127      [6] = { .phy = HALF,   24000,    0x00,        48,   4 },
 128      [7] = { .phy = HALF,   27000,    0x00,        54,   4 }
 129     },
 130 };
 131
 132 static struct ieee80211_rate_table ieee80211_quarter_table = {
 133     .rateCount = 8,
 134     .info = {
 135 /*                                   short            ctrl  */
 136 /*                                Preamble  dot11Rate Rate */
 137      [0] = { .phy = QUART,   1500,    0x00,      B(3),   0 },
 138      [1] = { .phy = QUART,   2250,    0x00,         4,   0 },
 139      [2] = { .phy = QUART,   3000,    0x00,      B(9),   2 },
 140      [3] = { .phy = QUART,   4500,    0x00,         9,   2 },
 141      [4] = { .phy = QUART,   6000,    0x00,     B(12),   4 },
 142      [5] = { .phy = QUART,   9000,    0x00,        18,   4 },
 143      [6] = { .phy = QUART,  12000,    0x00,        24,   4 },
 144      [7] = { .phy = QUART,  13500,    0x00,        27,   4 }
 145     },
 146 };
 147
 148 static struct ieee80211_rate_table ieee80211_turbog_table = {
 149     .rateCount = 7,
 150     .info = {
 151 /*                                   short            ctrl  */
 152 /*                                Preamble  dot11Rate Rate */
 153      [0] = { .phy = TURBO,   12000,   0x00,     B(12),   0 },
 154      [1] = { .phy = TURBO,   24000,   0x00,     B(24),   1 },
 155      [2] = { .phy = TURBO,   36000,   0x00,        36,   1 },
 156      [3] = { .phy = TURBO,   48000,   0x00,     B(48),   3 },
 157      [4] = { .phy = TURBO,   72000,   0x00,        72,   3 },
 158      [5] = { .phy = TURBO,   96000,   0x00,        96,   3 },
 159      [6] = { .phy = TURBO,  108000,   0x00,       108,   3 }
 160     },
 161 };
 162
 163 static struct ieee80211_rate_table ieee80211_turboa_table = {
 164     .rateCount = 8,
 165     .info = {
 166 /*                                   short            ctrl  */
 167 /*                                Preamble  dot11Rate Rate */
 168      [0] = { .phy = TURBO,   12000,   0x00,     B(12),   0 },
 169      [1] = { .phy = TURBO,   18000,   0x00,        18,   0 },
 170      [2] = { .phy = TURBO,   24000,   0x00,     B(24),   2 },
 171      [3] = { .phy = TURBO,   36000,   0x00,        36,   2 },
 172      [4] = { .phy = TURBO,   48000,   0x00,     B(48),   4 },
 173      [5] = { .phy = TURBO,   72000,   0x00,        72,   4 },
 174      [6] = { .phy = TURBO,   96000,   0x00,        96,   4 },
 175      [7] = { .phy = TURBO,  108000,   0x00,       108,   4 }
 176     },
 177 };
 178
 179 #undef  Mb
 180 #undef  B
 181 #undef  OFDM
 182 #undef  HALF
 183 #undef  QUART
 184 #undef  CCK
 185 #undef  TURBO
 186 #undef  XR
 187
 188 /*
 189  * Setup a rate table's reverse lookup table and fill in
 190  * ack durations.  The reverse lookup tables are assumed
 191  * to be initialized to zero (or at least the first entry).
 192  * We use this as a key that indicates whether or not
 193  * we've previously setup the reverse lookup table.
 194  *
 195  * XXX not reentrant, but shouldn't matter
 196  */
 197 static void
 198 ieee80211_setup_ratetable(struct ieee80211_rate_table *rt)
 199 {
 200 #define N(a)    (sizeof(a)/sizeof(a[0]))
 201 #define WLAN_CTRL_FRAME_SIZE \
 202         (sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN)
 203
 204         int i;
 205
 206         for (i = 0; i < N(rt->rateCodeToIndex); i++)
 207                 rt->rateCodeToIndex[i] = (uint8_t) -1;
 208         for (i = 0; i < rt->rateCount; i++) {
 209                 uint8_t code = rt->info[i].dot11Rate;
 210                 uint8_t cix = rt->info[i].ctlRateIndex;
 211                 uint8_t ctl_rate = rt->info[cix].dot11Rate;
 212
 213                 rt->rateCodeToIndex[code] = i;
 214                 if (code & IEEE80211_RATE_BASIC) {
 215                         /*
 216                          * Map w/o basic rate bit too.
 217                          */
 218                         code &= IEEE80211_RATE_VAL;
 219                         rt->rateCodeToIndex[code] = i;
 220                 }
 221
 222                 /*
 223                  * XXX for 11g the control rate to use for 5.5 and 11 Mb/s
 224                  *     depends on whether they are marked as basic rates;
 225                  *     the static tables are setup with an 11b-compatible
 226                  *     2Mb/s rate which will work but is suboptimal
 227                  *
 228                  * NB: Control rate is always less than or equal to the
 229                  *     current rate, so control rate's reverse lookup entry
 230                  *     has been installed and following call is safe.
 231                  */
 232                 rt->info[i].lpAckDuration = ieee80211_compute_duration(rt,
 233                         WLAN_CTRL_FRAME_SIZE, ctl_rate, 0);
 234                 rt->info[i].spAckDuration = ieee80211_compute_duration(rt,
 235                         WLAN_CTRL_FRAME_SIZE, ctl_rate, IEEE80211_F_SHPREAMBLE);
 236         }
 237
 238 #undef WLAN_CTRL_FRAME_SIZE
 239 #undef N
 240 }
 241
 242 /* Setup all rate tables */
 243 static void
 244 ieee80211_phy_init(void)
 245 {
 246 #define N(arr)  (int)(sizeof(arr) / sizeof(arr[0]))
 247         static struct ieee80211_rate_table * const ratetables[] = {
 248                 &ieee80211_half_table,
 249                 &ieee80211_quarter_table,
 250                 &ieee80211_11a_table,
 251                 &ieee80211_11g_table,
 252                 &ieee80211_turbog_table,
 253                 &ieee80211_turboa_table,
 254                 &ieee80211_turboa_table,
 255                 &ieee80211_11a_table,
 256                 &ieee80211_11g_table,
 257                 &ieee80211_11b_table
 258         };
 259         int i;
 260
 261         for (i = 0; i < N(ratetables); ++i)
 262                 ieee80211_setup_ratetable(ratetables[i]);
 263
 264 #undef N
 265 }
 266 SYSINIT(wlan_phy, SI_SUB_DRIVERS, SI_ORDER_FIRST, ieee80211_phy_init, NULL);
 267
 268 const struct ieee80211_rate_table *
 269 ieee80211_get_ratetable(struct ieee80211_channel *c)
 270 {
 271         const struct ieee80211_rate_table *rt;
 272
 273         /* XXX HT */
 274         if (IEEE80211_IS_CHAN_HALF(c))
 275                 rt = &ieee80211_half_table;
 276         else if (IEEE80211_IS_CHAN_QUARTER(c))
 277                 rt = &ieee80211_quarter_table;
 278         else if (IEEE80211_IS_CHAN_HTA(c))
 279                 rt = &ieee80211_11a_table;      /* XXX */
 280         else if (IEEE80211_IS_CHAN_HTG(c))
 281                 rt = &ieee80211_11g_table;      /* XXX */
 282         else if (IEEE80211_IS_CHAN_108G(c))
 283                 rt = &ieee80211_turbog_table;
 284         else if (IEEE80211_IS_CHAN_ST(c))
 285                 rt = &ieee80211_turboa_table;
 286         else if (IEEE80211_IS_CHAN_TURBO(c))
 287                 rt = &ieee80211_turboa_table;
 288         else if (IEEE80211_IS_CHAN_A(c))
 289                 rt = &ieee80211_11a_table;
 290         else if (IEEE80211_IS_CHAN_ANYG(c))
 291                 rt = &ieee80211_11g_table;
 292         else if (IEEE80211_IS_CHAN_B(c))
 293                 rt = &ieee80211_11b_table;
 294         else {
 295                 /* NB: should not get here */
 296                 panic("%s: no rate table for channel; freq %u flags 0x%x\n",
 297                       __func__, c->ic_freq, c->ic_flags);
 298         }
 299         return rt;
 300 }
 301
 302 /*
 303  * Convert PLCP signal/rate field to 802.11 rate (.5Mbits/s)
 304  *
 305  * Note we do no parameter checking; this routine is mainly
 306  * used to derive an 802.11 rate for constructing radiotap
 307  * header data for rx frames.
 308  *
 309  * XXX might be a candidate for inline
 310  */
 311 uint8_t
 312 ieee80211_plcp2rate(uint8_t plcp, enum ieee80211_phytype type)
 313 {
 314         if (type == IEEE80211_T_OFDM) {
 315                 static const uint8_t ofdm_plcp2rate[16] = {
 316                         [0xb]   = 12,
 317                         [0xf]   = 18,
 318                         [0xa]   = 24,
 319                         [0xe]   = 36,
 320                         [0x9]   = 48,
 321                         [0xd]   = 72,
 322                         [0x8]   = 96,
 323                         [0xc]   = 108
 324                 };
 325                 return ofdm_plcp2rate[plcp & 0xf];
 326         }
 327         if (type == IEEE80211_T_CCK) {
 328                 static const uint8_t cck_plcp2rate[16] = {
 329                         [0xa]   = 2,    /* 0x0a */
 330                         [0x4]   = 4,    /* 0x14 */
 331                         [0x7]   = 11,   /* 0x37 */
 332                         [0xe]   = 22,   /* 0x6e */
 333                         [0xc]   = 44,   /* 0xdc , actually PBCC */
 334                 };
 335                 return cck_plcp2rate[plcp & 0xf];
 336         }
 337         return 0;
 338 }
 339
 340 /*
 341  * Covert 802.11 rate to PLCP signal.
 342  */
 343 uint8_t
 344 ieee80211_rate2plcp(int rate, enum ieee80211_phytype type)
 345 {
 346         /* XXX ignore type for now since rates are unique */
 347         switch (rate) {
 348         /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
 349         case 12:        return 0xb;
 350         case 18:        return 0xf;
 351         case 24:        return 0xa;
 352         case 36:        return 0xe;
 353         case 48:        return 0x9;
 354         case 72:        return 0xd;
 355         case 96:        return 0x8;
 356         case 108:       return 0xc;
 357         /* CCK rates (IEEE Std 802.11b-1999 page 15, subclause 18.2.3.3) */
 358         case 2:         return 10;
 359         case 4:         return 20;
 360         case 11:        return 55;
 361         case 22:        return 110;
 362         /* IEEE Std 802.11g-2003 page 19, subclause 19.3.2.1 */
 363         case 44:        return 220;
 364         }
 365         return 0;               /* XXX unsupported/unknown rate */
 366 }
 367
 368 #define CCK_SIFS_TIME           10
 369 #define CCK_PREAMBLE_BITS       144
 370 #define CCK_PLCP_BITS           48
 371
 372 #define OFDM_SIFS_TIME          16
 373 #define OFDM_PREAMBLE_TIME      20
 374 #define OFDM_PLCP_BITS          22
 375 #define OFDM_SYMBOL_TIME        4
 376
 377 #define OFDM_HALF_SIFS_TIME     32
 378 #define OFDM_HALF_PREAMBLE_TIME 40
 379 #define OFDM_HALF_PLCP_BITS     22
 380 #define OFDM_HALF_SYMBOL_TIME   8
 381
 382 #define OFDM_QUARTER_SIFS_TIME          64
 383 #define OFDM_QUARTER_PREAMBLE_TIME      80
 384 #define OFDM_QUARTER_PLCP_BITS          22
 385 #define OFDM_QUARTER_SYMBOL_TIME        16
 386
 387 #define TURBO_SIFS_TIME         8
 388 #define TURBO_PREAMBLE_TIME     14
 389 #define TURBO_PLCP_BITS         22
 390 #define TURBO_SYMBOL_TIME       4
 391
 392 /*
 393  * Compute the time to transmit a frame of length frameLen bytes
 394  * using the specified rate, phy, and short preamble setting.
 395  * SIFS is included.
 396  */
 397 uint16_t
 398 ieee80211_compute_duration(const struct ieee80211_rate_table *rt,
 399         uint32_t frameLen, uint16_t rate, int isShortPreamble)
 400 {
 401         uint8_t rix = rt->rateCodeToIndex[rate];
 402         uint32_t bitsPerSymbol, numBits, numSymbols, phyTime, txTime;
 403         uint32_t kbps;
 404
 405         KASSERT(rix != (uint8_t)-1, ("rate %d has no info", rate));
 406         kbps = rt->info[rix].rateKbps;
 407         if (kbps == 0)                  /* XXX bandaid for channel changes */
 408                 return 0;
 409
 410         switch (rt->info[rix].phy) {
 411         case IEEE80211_T_CCK:
 412                 phyTime         = CCK_PREAMBLE_BITS + CCK_PLCP_BITS;
 413                 if (isShortPreamble && rt->info[rix].shortPreamble)
 414                         phyTime >>= 1;
 415                 numBits         = frameLen << 3;
 416                 txTime          = CCK_SIFS_TIME + phyTime
 417                                 + ((numBits * 1000)/kbps);
 418                 break;
 419         case IEEE80211_T_OFDM:
 420                 bitsPerSymbol   = (kbps * OFDM_SYMBOL_TIME) / 1000;
 421                 KASSERT(bitsPerSymbol != 0, ("full rate bps"));
 422
 423                 numBits         = OFDM_PLCP_BITS + (frameLen << 3);
 424                 numSymbols      = howmany(numBits, bitsPerSymbol);
 425                 txTime          = OFDM_SIFS_TIME
 426                                 + OFDM_PREAMBLE_TIME
 427                                 + (numSymbols * OFDM_SYMBOL_TIME);
 428                 break;
 429         case IEEE80211_T_OFDM_HALF:
 430                 bitsPerSymbol   = (kbps * OFDM_HALF_SYMBOL_TIME) / 1000;
 431                 KASSERT(bitsPerSymbol != 0, ("1/4 rate bps"));
 432
 433                 numBits         = OFDM_PLCP_BITS + (frameLen << 3);
 434                 numSymbols      = howmany(numBits, bitsPerSymbol);
 435                 txTime          = OFDM_HALF_SIFS_TIME
 436                                 + OFDM_HALF_PREAMBLE_TIME
 437                                 + (numSymbols * OFDM_HALF_SYMBOL_TIME);
 438                 break;
 439         case IEEE80211_T_OFDM_QUARTER:
 440                 bitsPerSymbol   = (kbps * OFDM_QUARTER_SYMBOL_TIME) / 1000;
 441                 KASSERT(bitsPerSymbol != 0, ("1/2 rate bps"));
 442
 443                 numBits         = OFDM_PLCP_BITS + (frameLen << 3);
 444                 numSymbols      = howmany(numBits, bitsPerSymbol);
 445                 txTime          = OFDM_QUARTER_SIFS_TIME
 446                                 + OFDM_QUARTER_PREAMBLE_TIME
 447                                 + (numSymbols * OFDM_QUARTER_SYMBOL_TIME);
 448                 break;
 449         case IEEE80211_T_TURBO:
 450                 /* we still save OFDM rates in kbps - so double them */
 451                 bitsPerSymbol = ((kbps << 1) * TURBO_SYMBOL_TIME) / 1000;
 452                 KASSERT(bitsPerSymbol != 0, ("turbo bps"));
 453
 454                 numBits       = TURBO_PLCP_BITS + (frameLen << 3);
 455                 numSymbols    = howmany(numBits, bitsPerSymbol);
 456                 txTime        = TURBO_SIFS_TIME + TURBO_PREAMBLE_TIME
 457                               + (numSymbols * TURBO_SYMBOL_TIME);
 458                 break;
 459         default:
 460                 panic("%s: unknown phy %u (rate %u)\n", __func__,
 461                       rt->info[rix].phy, rate);
 462                 break;
 463         }
 464         return txTime;
 465 }