tools/tools/net80211/wlantxtime/wlantxtime.c

   1 /*-
   2  * Copyright (c) 2007-2009 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  * FreeBSD: src/tools/tools/net80211/wlantxtime/wlantxtime.c,v 1.2 2009/02/19 05:36:07 sam Exp $
  26  */
  27
  28 /*
  29  * IEEE 802.11 PHY-related support.
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/types.h>
  34
  35 #include <net/if_llc.h>
  36
  37 #include <netproto/802_11/_ieee80211.h>
  38 #include <netproto/802_11/ieee80211.h>
  39
  40 #define IEEE80211_F_SHPREAMBLE  0x00040000      /* STATUS: use short preamble */
  41
  42 #include <err.h>
  43 #include <stdio.h>
  44 #include <stdarg.h>
  45 #include <stdlib.h>
  46 #include <strings.h>
  47 #include <unistd.h>
  48
  49 struct ieee80211_rate_table {
  50         int             rateCount;              /* NB: for proper padding */
  51         uint8_t         rateCodeToIndex[256];   /* back mapping */
  52         struct {
  53                 uint8_t         phy;            /* CCK/OFDM/TURBO */
  54                 uint32_t        rateKbps;       /* transfer rate in kbs */
  55                 uint8_t         shortPreamble;  /* mask for enabling short
  56                                                  * preamble in CCK rate code */
  57                 uint8_t         dot11Rate;      /* value for supported rates
  58                                                  * info element of MLME */
  59                 uint8_t         ctlRateIndex;   /* index of next lower basic
  60                                                  * rate; used for dur. calcs */
  61                 uint16_t        lpAckDuration;  /* long preamble ACK dur. */
  62                 uint16_t        spAckDuration;  /* short preamble ACK dur. */
  63         } info[32];
  64 };
  65
  66 uint16_t
  67 ieee80211_compute_duration(const struct ieee80211_rate_table *rt,
  68         uint32_t frameLen, uint16_t rate, int isShortPreamble);
  69
  70 #define KASSERT(c, msg) do {                    \
  71         if (!(c)) {                             \
  72                 printf msg;                     \
  73                 putchar('\n');                  \
  74                 exit(-1);                       \
  75         }                                       \
  76 } while (0)
  77
  78 static void
  79 panic(const char *fmt, ...)
  80 {
  81         va_list ap;
  82
  83         va_start(ap, fmt);
  84         vprintf(fmt, ap);
  85         va_end(ap);
  86         exit(-1);
  87 }
  88
  89 /* shorthands to compact tables for readability */
  90 #define OFDM    IEEE80211_T_OFDM
  91 #define CCK     IEEE80211_T_CCK
  92 #define TURBO   IEEE80211_T_TURBO
  93 #define HALF    IEEE80211_T_OFDM_HALF
  94 #define QUART   IEEE80211_T_OFDM_QUARTER
  95 #define PBCC    (IEEE80211_T_OFDM_QUARTER+1)            /* XXX */
  96 #define B(r)    (0x80 | r)
  97 #define Mb(x)   (x*1000)
  98
  99 static struct ieee80211_rate_table ieee80211_11b_table = {
 100     .rateCount = 4,             /* XXX no PBCC */
 101     .info = {
 102 /*                                   short            ctrl  */
 103 /*                                Preamble  dot11Rate Rate */
 104      [0] = { .phy = CCK,     1000,    0x00,      B(2),   0 },/*   1 Mb */
 105      [1] = { .phy = CCK,     2000,    0x04,      B(4),   1 },/*   2 Mb */
 106      [2] = { .phy = CCK,     5500,    0x04,     B(11),   1 },/* 5.5 Mb */
 107      [3] = { .phy = CCK,    11000,    0x04,     B(22),   1 },/*  11 Mb */
 108      [4] = { .phy = PBCC,   22000,    0x04,        44,   3 } /*  22 Mb */
 109     },
 110 };
 111
 112 static struct ieee80211_rate_table ieee80211_11g_table = {
 113     .rateCount = 12,
 114     .info = {
 115 /*                                   short            ctrl  */
 116 /*                                Preamble  dot11Rate Rate */
 117      [0] = { .phy = CCK,     1000,    0x00,      B(2),   0 },
 118      [1] = { .phy = CCK,     2000,    0x04,      B(4),   1 },
 119      [2] = { .phy = CCK,     5500,    0x04,     B(11),   2 },
 120      [3] = { .phy = CCK,    11000,    0x04,     B(22),   3 },
 121      [4] = { .phy = OFDM,    6000,    0x00,        12,   4 },
 122      [5] = { .phy = OFDM,    9000,    0x00,        18,   4 },
 123      [6] = { .phy = OFDM,   12000,    0x00,        24,   6 },
 124      [7] = { .phy = OFDM,   18000,    0x00,        36,   6 },
 125      [8] = { .phy = OFDM,   24000,    0x00,        48,   8 },
 126      [9] = { .phy = OFDM,   36000,    0x00,        72,   8 },
 127     [10] = { .phy = OFDM,   48000,    0x00,        96,   8 },
 128     [11] = { .phy = OFDM,   54000,    0x00,       108,   8 }
 129     },
 130 };
 131
 132 static struct ieee80211_rate_table ieee80211_11a_table = {
 133     .rateCount = 8,
 134     .info = {
 135 /*                                   short            ctrl  */
 136 /*                                Preamble  dot11Rate Rate */
 137      [0] = { .phy = OFDM,    6000,    0x00,     B(12),   0 },
 138      [1] = { .phy = OFDM,    9000,    0x00,        18,   0 },
 139      [2] = { .phy = OFDM,   12000,    0x00,     B(24),   2 },
 140      [3] = { .phy = OFDM,   18000,    0x00,        36,   2 },
 141      [4] = { .phy = OFDM,   24000,    0x00,     B(48),   4 },
 142      [5] = { .phy = OFDM,   36000,    0x00,        72,   4 },
 143      [6] = { .phy = OFDM,   48000,    0x00,        96,   4 },
 144      [7] = { .phy = OFDM,   54000,    0x00,       108,   4 }
 145     },
 146 };
 147
 148 static struct ieee80211_rate_table ieee80211_half_table = {
 149     .rateCount = 8,
 150     .info = {
 151 /*                                   short            ctrl  */
 152 /*                                Preamble  dot11Rate Rate */
 153      [0] = { .phy = HALF,    3000,    0x00,      B(6),   0 },
 154      [1] = { .phy = HALF,    4500,    0x00,         9,   0 },
 155      [2] = { .phy = HALF,    6000,    0x00,     B(12),   2 },
 156      [3] = { .phy = HALF,    9000,    0x00,        18,   2 },
 157      [4] = { .phy = HALF,   12000,    0x00,     B(24),   4 },
 158      [5] = { .phy = HALF,   18000,    0x00,        36,   4 },
 159      [6] = { .phy = HALF,   24000,    0x00,        48,   4 },
 160      [7] = { .phy = HALF,   27000,    0x00,        54,   4 }
 161     },
 162 };
 163
 164 static struct ieee80211_rate_table ieee80211_quarter_table = {
 165     .rateCount = 8,
 166     .info = {
 167 /*                                   short            ctrl  */
 168 /*                                Preamble  dot11Rate Rate */
 169      [0] = { .phy = QUART,   1500,    0x00,      B(3),   0 },
 170      [1] = { .phy = QUART,   2250,    0x00,         4,   0 },
 171      [2] = { .phy = QUART,   3000,    0x00,      B(9),   2 },
 172      [3] = { .phy = QUART,   4500,    0x00,         9,   2 },
 173      [4] = { .phy = QUART,   6000,    0x00,     B(12),   4 },
 174      [5] = { .phy = QUART,   9000,    0x00,        18,   4 },
 175      [6] = { .phy = QUART,  12000,    0x00,        24,   4 },
 176      [7] = { .phy = QUART,  13500,    0x00,        27,   4 }
 177     },
 178 };
 179
 180 static struct ieee80211_rate_table ieee80211_turbog_table = {
 181     .rateCount = 7,
 182     .info = {
 183 /*                                   short            ctrl  */
 184 /*                                Preamble  dot11Rate Rate */
 185      [0] = { .phy = TURBO,   12000,   0x00,     B(12),   0 },
 186      [1] = { .phy = TURBO,   24000,   0x00,     B(24),   1 },
 187      [2] = { .phy = TURBO,   36000,   0x00,        36,   1 },
 188      [3] = { .phy = TURBO,   48000,   0x00,     B(48),   3 },
 189      [4] = { .phy = TURBO,   72000,   0x00,        72,   3 },
 190      [5] = { .phy = TURBO,   96000,   0x00,        96,   3 },
 191      [6] = { .phy = TURBO,  108000,   0x00,       108,   3 }
 192     },
 193 };
 194
 195 static struct ieee80211_rate_table ieee80211_turboa_table = {
 196     .rateCount = 8,
 197     .info = {
 198 /*                                   short            ctrl  */
 199 /*                                Preamble  dot11Rate Rate */
 200      [0] = { .phy = TURBO,   12000,   0x00,     B(12),   0 },
 201      [1] = { .phy = TURBO,   18000,   0x00,        18,   0 },
 202      [2] = { .phy = TURBO,   24000,   0x00,     B(24),   2 },
 203      [3] = { .phy = TURBO,   36000,   0x00,        36,   2 },
 204      [4] = { .phy = TURBO,   48000,   0x00,     B(48),   4 },
 205      [5] = { .phy = TURBO,   72000,   0x00,        72,   4 },
 206      [6] = { .phy = TURBO,   96000,   0x00,        96,   4 },
 207      [7] = { .phy = TURBO,  108000,   0x00,       108,   4 }
 208     },
 209 };
 210
 211 #undef  Mb
 212 #undef  B
 213 #undef  OFDM
 214 #undef  CCK
 215 #undef  TURBO
 216 #undef  XR
 217
 218 /*
 219  * Setup a rate table's reverse lookup table and fill in
 220  * ack durations.  The reverse lookup tables are assumed
 221  * to be initialized to zero (or at least the first entry).
 222  * We use this as a key that indicates whether or not
 223  * we've previously setup the reverse lookup table.
 224  *
 225  * XXX not reentrant, but shouldn't matter
 226  */
 227 static void
 228 ieee80211_setup_ratetable(struct ieee80211_rate_table *rt)
 229 {
 230 #define N(a)    (sizeof(a)/sizeof(a[0]))
 231 #define WLAN_CTRL_FRAME_SIZE \
 232         (sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN)
 233
 234         int i;
 235
 236         for (i = 0; i < N(rt->rateCodeToIndex); i++)
 237                 rt->rateCodeToIndex[i] = (uint8_t) -1;
 238         for (i = 0; i < rt->rateCount; i++) {
 239                 uint8_t code = rt->info[i].dot11Rate;
 240                 uint8_t cix = rt->info[i].ctlRateIndex;
 241                 uint8_t ctl_rate = rt->info[cix].dot11Rate;
 242
 243                 rt->rateCodeToIndex[code] = i;
 244                 if (code & IEEE80211_RATE_BASIC) {
 245                         /*
 246                          * Map w/o basic rate bit too.
 247                          */
 248                         code &= IEEE80211_RATE_VAL;
 249                         rt->rateCodeToIndex[code] = i;
 250                 }
 251
 252                 /*
 253                  * XXX for 11g the control rate to use for 5.5 and 11 Mb/s
 254                  *     depends on whether they are marked as basic rates;
 255                  *     the static tables are setup with an 11b-compatible
 256                  *     2Mb/s rate which will work but is suboptimal
 257                  *
 258                  * NB: Control rate is always less than or equal to the
 259                  *     current rate, so control rate's reverse lookup entry
 260                  *     has been installed and following call is safe.
 261                  */
 262                 rt->info[i].lpAckDuration = ieee80211_compute_duration(rt,
 263                         WLAN_CTRL_FRAME_SIZE, ctl_rate, 0);
 264                 rt->info[i].spAckDuration = ieee80211_compute_duration(rt,
 265                         WLAN_CTRL_FRAME_SIZE, ctl_rate, IEEE80211_F_SHPREAMBLE);
 266         }
 267
 268 #undef WLAN_CTRL_FRAME_SIZE
 269 #undef N
 270 }
 271
 272 /* Setup all rate tables */
 273 static void
 274 ieee80211_phy_init(void)
 275 {
 276 #define N(arr)  (int)(sizeof(arr) / sizeof(arr[0]))
 277         static struct ieee80211_rate_table * const ratetables[] = {
 278                 &ieee80211_half_table,
 279                 &ieee80211_quarter_table,
 280                 &ieee80211_11a_table,
 281                 &ieee80211_11g_table,
 282                 &ieee80211_turbog_table,
 283                 &ieee80211_turboa_table,
 284                 &ieee80211_turboa_table,
 285                 &ieee80211_11a_table,
 286                 &ieee80211_11g_table,
 287                 &ieee80211_11b_table
 288         };
 289         int i;
 290
 291         for (i = 0; i < N(ratetables); ++i)
 292                 ieee80211_setup_ratetable(ratetables[i]);
 293
 294 #undef N
 295 }
 296 #define CCK_SIFS_TIME           10
 297 #define CCK_PREAMBLE_BITS       144
 298 #define CCK_PLCP_BITS           48
 299
 300 #define OFDM_SIFS_TIME          16
 301 #define OFDM_PREAMBLE_TIME      20
 302 #define OFDM_PLCP_BITS          22
 303 #define OFDM_SYMBOL_TIME        4
 304
 305 #define OFDM_HALF_SIFS_TIME     32
 306 #define OFDM_HALF_PREAMBLE_TIME 40
 307 #define OFDM_HALF_PLCP_BITS     22
 308 #define OFDM_HALF_SYMBOL_TIME   8
 309
 310 #define OFDM_QUARTER_SIFS_TIME          64
 311 #define OFDM_QUARTER_PREAMBLE_TIME      80
 312 #define OFDM_QUARTER_PLCP_BITS          22
 313 #define OFDM_QUARTER_SYMBOL_TIME        16
 314
 315 #define TURBO_SIFS_TIME         8
 316 #define TURBO_PREAMBLE_TIME     14
 317 #define TURBO_PLCP_BITS         22
 318 #define TURBO_SYMBOL_TIME       4
 319
 320 #define HT_L_STF        8
 321 #define HT_L_LTF        8
 322 #define HT_L_SIG        4
 323 #define HT_SIG          8
 324 #define HT_STF          4
 325 #define HT_LTF(n)       ((n) * 4)
 326
 327 /*
 328  * Compute the time to transmit a frame of length frameLen bytes
 329  * using the specified rate, phy, and short preamble setting.
 330  * SIFS is included.
 331  */
 332 uint16_t
 333 ieee80211_compute_duration(const struct ieee80211_rate_table *rt,
 334         uint32_t frameLen, uint16_t rate, int isShortPreamble)
 335 {
 336         uint8_t rix = rt->rateCodeToIndex[rate];
 337         uint32_t bitsPerSymbol, numBits, numSymbols, phyTime, txTime;
 338         uint32_t kbps;
 339
 340         KASSERT(rix != (uint8_t)-1, ("rate %d has no info", rate));
 341         kbps = rt->info[rix].rateKbps;
 342         if (kbps == 0)                  /* XXX bandaid for channel changes */
 343                 return 0;
 344
 345         switch (rt->info[rix].phy) {
 346         case IEEE80211_T_CCK:
 347                 phyTime         = CCK_PREAMBLE_BITS + CCK_PLCP_BITS;
 348                 if (isShortPreamble && rt->info[rix].shortPreamble)
 349                         phyTime >>= 1;
 350                 numBits         = frameLen << 3;
 351                 txTime          = CCK_SIFS_TIME + phyTime
 352                                 + ((numBits * 1000)/kbps);
 353                 break;
 354         case IEEE80211_T_OFDM:
 355                 bitsPerSymbol   = (kbps * OFDM_SYMBOL_TIME) / 1000;
 356                 KASSERT(bitsPerSymbol != 0, ("full rate bps"));
 357
 358                 numBits         = OFDM_PLCP_BITS + (frameLen << 3);
 359                 numSymbols      = howmany(numBits, bitsPerSymbol);
 360                 txTime          = OFDM_SIFS_TIME
 361                                 + OFDM_PREAMBLE_TIME
 362                                 + (numSymbols * OFDM_SYMBOL_TIME);
 363                 break;
 364         case IEEE80211_T_OFDM_HALF:
 365                 bitsPerSymbol   = (kbps * OFDM_HALF_SYMBOL_TIME) / 1000;
 366                 KASSERT(bitsPerSymbol != 0, ("1/4 rate bps"));
 367
 368                 numBits         = OFDM_PLCP_BITS + (frameLen << 3);
 369                 numSymbols      = howmany(numBits, bitsPerSymbol);
 370                 txTime          = OFDM_HALF_SIFS_TIME
 371                                 + OFDM_HALF_PREAMBLE_TIME
 372                                 + (numSymbols * OFDM_HALF_SYMBOL_TIME);
 373                 break;
 374         case IEEE80211_T_OFDM_QUARTER:
 375                 bitsPerSymbol   = (kbps * OFDM_QUARTER_SYMBOL_TIME) / 1000;
 376                 KASSERT(bitsPerSymbol != 0, ("1/2 rate bps"));
 377
 378                 numBits         = OFDM_PLCP_BITS + (frameLen << 3);
 379                 numSymbols      = howmany(numBits, bitsPerSymbol);
 380                 txTime          = OFDM_QUARTER_SIFS_TIME
 381                                 + OFDM_QUARTER_PREAMBLE_TIME
 382                                 + (numSymbols * OFDM_QUARTER_SYMBOL_TIME);
 383                 break;
 384         case IEEE80211_T_TURBO:
 385                 /* we still save OFDM rates in kbps - so double them */
 386                 bitsPerSymbol = ((kbps << 1) * TURBO_SYMBOL_TIME) / 1000;
 387                 KASSERT(bitsPerSymbol != 0, ("turbo bps"));
 388
 389                 numBits       = TURBO_PLCP_BITS + (frameLen << 3);
 390                 numSymbols    = howmany(numBits, bitsPerSymbol);
 391                 txTime        = TURBO_SIFS_TIME + TURBO_PREAMBLE_TIME
 392                               + (numSymbols * TURBO_SYMBOL_TIME);
 393                 break;
 394         default:
 395                 panic("%s: unknown phy %u (rate %u)\n", __func__,
 396                       rt->info[rix].phy, rate);
 397                 break;
 398         }
 399         return txTime;
 400 }
 401
 402 uint32_t
 403 ieee80211_compute_duration_ht(const struct ieee80211_rate_table *rt,
 404         uint32_t frameLen, uint16_t rate,
 405         int streams, int isht40, int isShortGI)
 406 {
 407         static const uint16_t ht20_bps[16] = {
 408             26, 52, 78, 104, 156, 208, 234, 260,
 409             52, 104, 156, 208, 312, 416, 468, 520
 410         };
 411         static const uint16_t ht40_bps[16] = {
 412             54, 108, 162, 216, 324, 432, 486, 540,
 413             108, 216, 324, 432, 648, 864, 972, 1080,
 414         };
 415         uint32_t bitsPerSymbol, numBits, numSymbols, txTime;
 416
 417         KASSERT(rate & IEEE80211_RATE_MCS, ("not mcs %d", rate));
 418         KASSERT((rate &~ IEEE80211_RATE_MCS) < 16, ("bad mcs 0x%x", rate));
 419
 420         if (isht40)
 421                 bitsPerSymbol = ht40_bps[rate & 0xf];
 422         else
 423                 bitsPerSymbol = ht20_bps[rate & 0xf];
 424         numBits = OFDM_PLCP_BITS + (frameLen << 3);
 425         numSymbols = howmany(numBits, bitsPerSymbol);
 426         if (isShortGI)
 427                 txTime = ((numSymbols * 18) + 4) / 5;   /* 3.6us */
 428         else
 429                 txTime = numSymbols * 4;                /* 4us */
 430         return txTime + HT_L_STF + HT_L_LTF +
 431             HT_L_SIG + HT_SIG + HT_STF + HT_LTF(streams);
 432 }
 433
 434 static const struct ieee80211_rate_table *
 435 mode2table(const char *mode)
 436 {
 437         if (strcasecmp(mode, "half") == 0)
 438                 return &ieee80211_half_table;
 439         else if (strcasecmp(mode, "quarter") == 0)
 440                 return &ieee80211_quarter_table;
 441         else if (strcasecmp(mode, "hta") == 0)
 442                 return &ieee80211_11a_table;    /* XXX */
 443         else if (strcasecmp(mode, "htg") == 0)
 444                 return &ieee80211_11g_table;    /* XXX */
 445         else if (strcasecmp(mode, "108g") == 0)
 446                 return &ieee80211_turbog_table;
 447         else if (strcasecmp(mode, "sturbo") == 0)
 448                 return &ieee80211_turboa_table;
 449         else if (strcasecmp(mode, "turbo") == 0)
 450                 return &ieee80211_turboa_table;
 451         else if (strcasecmp(mode, "11a") == 0)
 452                 return &ieee80211_11a_table;
 453         else if (strcasecmp(mode, "11g") == 0)
 454                 return &ieee80211_11g_table;
 455         else if (strcasecmp(mode, "11b") == 0)
 456                 return &ieee80211_11b_table;
 457         else
 458                 return NULL;
 459 }
 460
 461 const char *
 462 srate(int rate)
 463 {
 464         static char buf[32];
 465         if (rate & 1)
 466                 snprintf(buf, sizeof(buf), "%u.5", rate/2);
 467         else
 468                 snprintf(buf, sizeof(buf), "%u", rate/2);
 469         return buf;
 470 }
 471
 472 static int
 473 checkpreamble(const struct ieee80211_rate_table *rt, uint8_t rix,
 474         int isShortPreamble, int verbose)
 475 {
 476         if (isShortPreamble) {
 477                 if (rt->info[rix].phy != IEEE80211_T_CCK) {
 478                         if (verbose)
 479                                 warnx("short preamble not meaningful, ignored");
 480                         isShortPreamble = 0;
 481                 } else if (!rt->info[rix].shortPreamble) {
 482                         if (verbose)
 483                                 warnx("short preamble not meaningful with "
 484                                     "rate %s, ignored",
 485                                     srate(rt->info[rix].dot11Rate &~ IEEE80211_RATE_BASIC));
 486                         isShortPreamble = 0;
 487                 }
 488         }
 489         return isShortPreamble;
 490 }
 491
 492 static void
 493 usage(const char *progname)
 494 {
 495         fprintf(stderr, "usage: %s [-a] [-l framelen] [-m mode] [-r rate] [-s]\n",
 496             progname);
 497         fprintf(stderr, "-a             display calculations for all possible rates\n");
 498         fprintf(stderr, "-l framelen    length in bytes of 802.11 payload (default 1536)\n");
 499         fprintf(stderr, "-m 11a         calculate for 11a channel\n");
 500         fprintf(stderr, "-m 11b         calculate for 11b channel\n");
 501         fprintf(stderr, "-m 11g         calculate for 11g channel (default)\n");
 502         fprintf(stderr, "-m half        calculate for 1/2 width channel\n");
 503         fprintf(stderr, "-m quarter     calculate for 1/4 width channel\n");
 504         fprintf(stderr, "-m 108g        calculate for dynamic turbo 11g channel\n");
 505         fprintf(stderr, "-m sturbo      calculate for static turbo channel\n");
 506         fprintf(stderr, "-m turbo       calculate for dynamic turbo 11a channel\n");
 507         fprintf(stderr, "-r rate        IEEE rate code (default 54)\n");
 508         fprintf(stderr, "-s             short preamble (default long)\n");
 509         exit(0);
 510 }
 511
 512 int
 513 main(int argc, char *argv[])
 514 {
 515         const struct ieee80211_rate_table *rt;
 516         const char *mode;
 517         uint32_t frameLen;
 518         uint16_t rate;
 519         uint16_t time;
 520         uint8_t rix;
 521         int ch, allrates, isShortPreamble, isShort;
 522         float frate;
 523
 524         ieee80211_phy_init();
 525
 526         mode = "11g";
 527         isShortPreamble = 0;
 528         frameLen = 1500
 529                  + sizeof(struct ieee80211_frame)
 530                  + LLC_SNAPFRAMELEN
 531                  + IEEE80211_CRC_LEN
 532                  ;
 533         rate = 2*54;
 534         allrates = 0;
 535         while ((ch = getopt(argc, argv, "al:m:r:s")) != -1) {
 536                 switch (ch) {
 537                 case 'a':
 538                         allrates = 1;
 539                         break;
 540                 case 'l':
 541                         frameLen = strtoul(optarg, NULL, 0);
 542                         break;
 543                 case 'm':
 544                         mode = optarg;
 545                         break;
 546                 case 'r':
 547                         frate = atof(optarg);
 548                         rate = (int) 2*frate;
 549                         break;
 550                 case 's':
 551                         isShortPreamble = 1;
 552                         break;
 553                 default:
 554                         usage(argv[0]);
 555                         break;
 556                 }
 557         }
 558         rt = mode2table(mode);
 559         if (rt == NULL)
 560                 errx(-1, "unknown mode %s", mode);
 561         if (!allrates) {
 562                 rix = rt->rateCodeToIndex[rate];
 563                 if (rix == (uint8_t) -1)
 564                         errx(-1, "rate %s not valid for mode %s", srate(rate), mode);
 565                 isShort = checkpreamble(rt, rix, isShortPreamble, 1);
 566
 567                 time = ieee80211_compute_duration(rt, frameLen, rate, isShort);
 568                 printf("%u usec to send %u bytes @ %s Mb/s, %s preamble\n",
 569                     time, frameLen, srate(rate),
 570                     isShort ? "short" : "long");
 571         } else {
 572                 for (rix = 0; rix < rt->rateCount; rix++) {
 573                         rate = rt->info[rix].dot11Rate &~ IEEE80211_RATE_BASIC;
 574                         isShort = checkpreamble(rt, rix, isShortPreamble, 0);
 575                         time = ieee80211_compute_duration(rt, frameLen, rate,
 576                             isShort);
 577                         printf("%u usec to send %u bytes @ %s Mb/s, %s preamble\n",
 578                             time, frameLen, srate(rate),
 579                             isShort ? "short" : "long");
 580                 }
 581         }
 582         return 0;
 583 }