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