1 /*- 2 * Copyright (c) 2017 Adrian Chadd <adrian@FreeBSD.org> 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 #ifdef __FreeBSD__ 28 __FBSDID("$FreeBSD$"); 29 #endif 30 31 /* 32 * IEEE 802.11ac-2013 protocol support. 33 */ 34 35 #include "opt_inet.h" 36 #include "opt_wlan.h" 37 38 #include <sys/param.h> 39 #include <sys/kernel.h> 40 #include <sys/malloc.h> 41 #include <sys/systm.h> 42 #include <sys/endian.h> 43 44 #include <sys/socket.h> 45 46 #include <net/if.h> 47 #include <net/if_var.h> 48 #include <net/if_media.h> 49 #include <net/ethernet.h> 50 51 #include <net80211/ieee80211_var.h> 52 #include <net80211/ieee80211_action.h> 53 #include <net80211/ieee80211_input.h> 54 #include <net80211/ieee80211_vht.h> 55 56 /* define here, used throughout file */ 57 #define MS(_v, _f) (((_v) & _f) >> _f##_S) 58 #define SM(_v, _f) (((_v) << _f##_S) & _f) 59 60 #define ADDSHORT(frm, v) do { \ 61 frm[0] = (v) & 0xff; \ 62 frm[1] = (v) >> 8; \ 63 frm += 2; \ 64 } while (0) 65 #define ADDWORD(frm, v) do { \ 66 frm[0] = (v) & 0xff; \ 67 frm[1] = ((v) >> 8) & 0xff; \ 68 frm[2] = ((v) >> 16) & 0xff; \ 69 frm[3] = ((v) >> 24) & 0xff; \ 70 frm += 4; \ 71 } while (0) 72 73 /* 74 * Immediate TODO: 75 * 76 * + handle WLAN_ACTION_VHT_OPMODE_NOTIF and other VHT action frames 77 * + ensure vhtinfo/vhtcap parameters correctly use the negotiated 78 * capabilities and ratesets 79 * + group ID management operation 80 */ 81 82 /* 83 * XXX TODO: handle WLAN_ACTION_VHT_OPMODE_NOTIF 84 * 85 * Look at mac80211/vht.c:ieee80211_vht_handle_opmode() for further details. 86 */ 87 88 static int 89 vht_recv_action_placeholder(struct ieee80211_node *ni, 90 const struct ieee80211_frame *wh, 91 const uint8_t *frm, const uint8_t *efrm) 92 { 93 94 #ifdef IEEE80211_DEBUG 95 ieee80211_note(ni->ni_vap, "%s: called; fc=0x%.2x/0x%.2x", 96 __func__, wh->i_fc[0], wh->i_fc[1]); 97 #endif 98 return (0); 99 } 100 101 static int 102 vht_send_action_placeholder(struct ieee80211_node *ni, 103 int category, int action, void *arg0) 104 { 105 106 #ifdef IEEE80211_DEBUG 107 ieee80211_note(ni->ni_vap, "%s: called; category=%d, action=%d", 108 __func__, category, action); 109 #endif 110 return (EINVAL); 111 } 112 113 static void 114 ieee80211_vht_init(void) 115 { 116 117 ieee80211_recv_action_register(IEEE80211_ACTION_CAT_VHT, 118 WLAN_ACTION_VHT_COMPRESSED_BF, vht_recv_action_placeholder); 119 ieee80211_recv_action_register(IEEE80211_ACTION_CAT_VHT, 120 WLAN_ACTION_VHT_GROUPID_MGMT, vht_recv_action_placeholder); 121 ieee80211_recv_action_register(IEEE80211_ACTION_CAT_VHT, 122 WLAN_ACTION_VHT_OPMODE_NOTIF, vht_recv_action_placeholder); 123 124 ieee80211_send_action_register(IEEE80211_ACTION_CAT_VHT, 125 WLAN_ACTION_VHT_COMPRESSED_BF, vht_send_action_placeholder); 126 ieee80211_send_action_register(IEEE80211_ACTION_CAT_VHT, 127 WLAN_ACTION_VHT_GROUPID_MGMT, vht_send_action_placeholder); 128 ieee80211_send_action_register(IEEE80211_ACTION_CAT_VHT, 129 WLAN_ACTION_VHT_OPMODE_NOTIF, vht_send_action_placeholder); 130 } 131 132 SYSINIT(wlan_vht, SI_SUB_DRIVERS, SI_ORDER_FIRST, ieee80211_vht_init, NULL); 133 134 void 135 ieee80211_vht_attach(struct ieee80211com *ic) 136 { 137 } 138 139 void 140 ieee80211_vht_detach(struct ieee80211com *ic) 141 { 142 } 143 144 void 145 ieee80211_vht_vattach(struct ieee80211vap *vap) 146 { 147 struct ieee80211com *ic = vap->iv_ic; 148 149 if (! IEEE80211_CONF_VHT(ic)) 150 return; 151 152 vap->iv_vhtcaps = ic->ic_vhtcaps; 153 vap->iv_vhtextcaps = ic->ic_vhtextcaps; 154 155 /* XXX assume VHT80 support; should really check vhtcaps */ 156 vap->iv_flags_vht = 157 IEEE80211_FVHT_VHT 158 | IEEE80211_FVHT_USEVHT40 159 | IEEE80211_FVHT_USEVHT80; 160 #if 0 161 /* XXX TODO: enable VHT80+80, VHT160 capabilities */ 162 if (XXX TODO FIXME) 163 vap->iv_flags_vht |= IEEE80211_FVHT_USEVHT160; 164 if (XXX TODO FIXME) 165 vap->iv_flags_vht |= IEEE80211_FVHT_USEVHT80P80; 166 #endif 167 168 memcpy(&vap->iv_vht_mcsinfo, &ic->ic_vht_mcsinfo, 169 sizeof(struct ieee80211_vht_mcs_info)); 170 } 171 172 void 173 ieee80211_vht_vdetach(struct ieee80211vap *vap) 174 { 175 } 176 177 #if 0 178 static void 179 vht_announce(struct ieee80211com *ic, enum ieee80211_phymode mode) 180 { 181 } 182 #endif 183 184 static int 185 vht_mcs_to_num(int m) 186 { 187 188 switch (m) { 189 case IEEE80211_VHT_MCS_SUPPORT_0_7: 190 return (7); 191 case IEEE80211_VHT_MCS_SUPPORT_0_8: 192 return (8); 193 case IEEE80211_VHT_MCS_SUPPORT_0_9: 194 return (9); 195 default: 196 return (0); 197 } 198 } 199 200 void 201 ieee80211_vht_announce(struct ieee80211com *ic) 202 { 203 int i, tx, rx; 204 205 if (! IEEE80211_CONF_VHT(ic)) 206 return; 207 208 /* Channel width */ 209 ic_printf(ic, "[VHT] Channel Widths: 20MHz, 40MHz, 80MHz"); 210 if (MS(ic->ic_vhtcaps, IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK) >= 1) 211 printf(" 160MHz"); 212 if (MS(ic->ic_vhtcaps, IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK) == 2) 213 printf(" 80+80MHz"); 214 printf("\n"); 215 216 /* Features */ 217 ic_printf(ic, "[VHT] Features: %b\n", ic->ic_vhtcaps, 218 IEEE80211_VHTCAP_BITS); 219 220 /* For now, just 5GHz VHT. Worry about 2GHz VHT later */ 221 for (i = 0; i < 8; i++) { 222 /* Each stream is 2 bits */ 223 tx = (ic->ic_vht_mcsinfo.tx_mcs_map >> (2*i)) & 0x3; 224 rx = (ic->ic_vht_mcsinfo.rx_mcs_map >> (2*i)) & 0x3; 225 if (tx == 3 && rx == 3) 226 continue; 227 ic_printf(ic, "[VHT] NSS %d: TX MCS 0..%d, RX MCS 0..%d\n", 228 i + 1, vht_mcs_to_num(tx), vht_mcs_to_num(rx)); 229 } 230 } 231 232 void 233 ieee80211_vht_node_init(struct ieee80211_node *ni) 234 { 235 236 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 237 "%s: called", __func__); 238 ni->ni_flags |= IEEE80211_NODE_VHT; 239 } 240 241 void 242 ieee80211_vht_node_cleanup(struct ieee80211_node *ni) 243 { 244 245 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 246 "%s: called", __func__); 247 ni->ni_flags &= ~IEEE80211_NODE_VHT; 248 ni->ni_vhtcap = 0; 249 bzero(&ni->ni_vht_mcsinfo, sizeof(struct ieee80211_vht_mcs_info)); 250 } 251 252 /* 253 * Parse an 802.11ac VHT operation IE. 254 */ 255 void 256 ieee80211_parse_vhtopmode(struct ieee80211_node *ni, const uint8_t *ie) 257 { 258 /* vht operation */ 259 ni->ni_vht_chanwidth = ie[2]; 260 ni->ni_vht_chan1 = ie[3]; 261 ni->ni_vht_chan2 = ie[4]; 262 ni->ni_vht_basicmcs = le16dec(ie + 5); 263 264 #if 0 265 printf("%s: chan1=%d, chan2=%d, chanwidth=%d, basicmcs=0x%04x\n", 266 __func__, ni->ni_vht_chan1, ni->ni_vht_chan2, ni->ni_vht_chanwidth, 267 ni->ni_vht_basicmcs); 268 #endif 269 } 270 271 /* 272 * Parse an 802.11ac VHT capability IE. 273 */ 274 void 275 ieee80211_parse_vhtcap(struct ieee80211_node *ni, const uint8_t *ie) 276 { 277 278 /* vht capability */ 279 ni->ni_vhtcap = le32dec(ie + 2); 280 281 /* suppmcs */ 282 ni->ni_vht_mcsinfo.rx_mcs_map = le16dec(ie + 6); 283 ni->ni_vht_mcsinfo.rx_highest = le16dec(ie + 8); 284 ni->ni_vht_mcsinfo.tx_mcs_map = le16dec(ie + 10); 285 ni->ni_vht_mcsinfo.tx_highest = le16dec(ie + 12); 286 } 287 288 int 289 ieee80211_vht_updateparams(struct ieee80211_node *ni, 290 const uint8_t *vhtcap_ie, 291 const uint8_t *vhtop_ie) 292 { 293 294 //printf("%s: called\n", __func__); 295 296 ieee80211_parse_vhtcap(ni, vhtcap_ie); 297 ieee80211_parse_vhtopmode(ni, vhtop_ie); 298 return (0); 299 } 300 301 void 302 ieee80211_setup_vht_rates(struct ieee80211_node *ni, 303 const uint8_t *vhtcap_ie, 304 const uint8_t *vhtop_ie) 305 { 306 307 //printf("%s: called\n", __func__); 308 /* XXX TODO */ 309 } 310 311 void 312 ieee80211_vht_timeout(struct ieee80211vap *vap) 313 { 314 } 315 316 void 317 ieee80211_vht_node_join(struct ieee80211_node *ni) 318 { 319 320 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 321 "%s: called", __func__); 322 } 323 324 void 325 ieee80211_vht_node_leave(struct ieee80211_node *ni) 326 { 327 328 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 329 "%s: called", __func__); 330 } 331 332 /* 333 * Calculate the VHTCAP IE for a given node. 334 * 335 * This includes calculating the capability intersection based on the 336 * current operating mode and intersection of the TX/RX MCS maps. 337 * 338 * The standard only makes it clear about MCS rate negotiation 339 * and MCS basic rates (which must be a subset of the general 340 * negotiated rates). It doesn't make it clear that the AP should 341 * figure out the minimum functional overlap with the STA and 342 * support that. 343 * 344 * Note: this is in host order, not in 802.11 endian order. 345 * 346 * TODO: ensure I re-read 9.7.11 Rate Selection for VHT STAs. 347 * 348 * TODO: investigate what we should negotiate for MU-MIMO beamforming 349 * options. 350 * 351 * opmode is '1' for "vhtcap as if I'm a STA", 0 otherwise. 352 */ 353 void 354 ieee80211_vht_get_vhtcap_ie(struct ieee80211_node *ni, 355 struct ieee80211_ie_vhtcap *vhtcap, int opmode) 356 { 357 struct ieee80211vap *vap = ni->ni_vap; 358 // struct ieee80211com *ic = vap->iv_ic; 359 uint32_t val, val1, val2; 360 uint32_t new_vhtcap; 361 int i; 362 363 vhtcap->ie = IEEE80211_ELEMID_VHT_CAP; 364 vhtcap->len = sizeof(struct ieee80211_ie_vhtcap) - 2; 365 366 /* 367 * Capabilities - it depends on whether we are a station 368 * or not. 369 */ 370 new_vhtcap = 0; 371 372 /* 373 * Station - use our desired configuration based on 374 * local config, local device bits and the already-learnt 375 * vhtcap/vhtinfo IE in the node. 376 */ 377 378 /* Limit MPDU size to the smaller of the two */ 379 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_MAX_MPDU_MASK); 380 if (opmode == 1) { 381 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_MAX_MPDU_MASK); 382 } 383 val = MIN(val1, val2); 384 new_vhtcap |= SM(val, IEEE80211_VHTCAP_MAX_MPDU_MASK); 385 386 /* Limit supp channel config */ 387 val2 = val1 = MS(vap->iv_vhtcaps, 388 IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK); 389 if (opmode == 1) { 390 val2 = MS(ni->ni_vhtcap, 391 IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK); 392 } 393 if ((val2 == 2) && 394 ((vap->iv_flags_vht & IEEE80211_FVHT_USEVHT80P80) == 0)) 395 val2 = 1; 396 if ((val2 == 1) && 397 ((vap->iv_flags_vht & IEEE80211_FVHT_USEVHT160) == 0)) 398 val2 = 0; 399 val = MIN(val1, val2); 400 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK); 401 402 /* RX LDPC */ 403 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_RXLDPC); 404 if (opmode == 1) { 405 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_RXLDPC); 406 } 407 val = MIN(val1, val2); 408 new_vhtcap |= SM(val, IEEE80211_VHTCAP_RXLDPC); 409 410 /* Short-GI 80 */ 411 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_SHORT_GI_80); 412 if (opmode == 1) { 413 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_SHORT_GI_80); 414 } 415 val = MIN(val1, val2); 416 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SHORT_GI_80); 417 418 /* Short-GI 160 */ 419 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_SHORT_GI_160); 420 if (opmode == 1) { 421 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_SHORT_GI_160); 422 } 423 val = MIN(val1, val2); 424 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SHORT_GI_160); 425 426 /* 427 * STBC is slightly more complicated. 428 * 429 * In non-STA mode, we just announce our capabilities and that 430 * is that. 431 * 432 * In STA mode, we should calculate our capabilities based on 433 * local capabilities /and/ what the remote says. So: 434 * 435 * + Only TX STBC if we support it and the remote supports RX STBC; 436 * + Only announce RX STBC if we support it and the remote supports 437 * TX STBC; 438 * + RX STBC should be the minimum of local and remote RX STBC; 439 */ 440 441 /* TX STBC */ 442 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_TXSTBC); 443 if (opmode == 1) { 444 /* STA mode - enable it only if node RXSTBC is non-zero */ 445 val2 = !! MS(ni->ni_vhtcap, IEEE80211_VHTCAP_RXSTBC_MASK); 446 } 447 val = MIN(val1, val2); 448 /* XXX For now, use the 11n config flag */ 449 if ((vap->iv_flags_ht & IEEE80211_FHT_STBC_TX) == 0) 450 val = 0; 451 new_vhtcap |= SM(val, IEEE80211_VHTCAP_TXSTBC); 452 453 /* RX STBC1..4 */ 454 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_RXSTBC_MASK); 455 if (opmode == 1) { 456 /* STA mode - enable it only if node TXSTBC is non-zero */ 457 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_TXSTBC); 458 } 459 val = MIN(val1, val2); 460 /* XXX For now, use the 11n config flag */ 461 if ((vap->iv_flags_ht & IEEE80211_FHT_STBC_RX) == 0) 462 val = 0; 463 new_vhtcap |= SM(val, IEEE80211_VHTCAP_RXSTBC_MASK); 464 465 /* 466 * Finally - if RXSTBC is 0, then don't enable TXSTBC. 467 * Strictly speaking a device can TXSTBC and not RXSTBC, but 468 * it would be silly. 469 */ 470 if (val == 0) 471 new_vhtcap &= ~IEEE80211_VHTCAP_TXSTBC; 472 473 /* 474 * Some of these fields require other fields to exist. 475 * So before using it, the parent field needs to be checked 476 * otherwise the overridden value may be wrong. 477 * 478 * For example, if SU beamformee is set to 0, then BF STS 479 * needs to be 0. 480 */ 481 482 /* SU Beamformer capable */ 483 val2 = val1 = MS(vap->iv_vhtcaps, 484 IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 485 if (opmode == 1) { 486 val2 = MS(ni->ni_vhtcap, 487 IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 488 } 489 val = MIN(val1, val2); 490 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 491 492 /* SU Beamformee capable */ 493 val2 = val1 = MS(vap->iv_vhtcaps, 494 IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 495 if (opmode == 1) { 496 val2 = MS(ni->ni_vhtcap, 497 IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 498 } 499 val = MIN(val1, val2); 500 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 501 502 /* Beamformee STS capability - only if SU beamformee capable */ 503 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_BEAMFORMEE_STS_MASK); 504 if (opmode == 1) { 505 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_BEAMFORMEE_STS_MASK); 506 } 507 val = MIN(val1, val2); 508 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE) == 0) 509 val = 0; 510 new_vhtcap |= SM(val, IEEE80211_VHTCAP_BEAMFORMEE_STS_MASK); 511 512 /* Sounding dimensions - only if SU beamformer capable */ 513 val2 = val1 = MS(vap->iv_vhtcaps, 514 IEEE80211_VHTCAP_SOUNDING_DIMENSIONS_MASK); 515 if (opmode == 1) 516 val2 = MS(ni->ni_vhtcap, 517 IEEE80211_VHTCAP_SOUNDING_DIMENSIONS_MASK); 518 val = MIN(val1, val2); 519 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE) == 0) 520 val = 0; 521 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SOUNDING_DIMENSIONS_MASK); 522 523 /* 524 * MU Beamformer capable - only if SU BFF capable, MU BFF capable 525 * and STA (not AP) 526 */ 527 val2 = val1 = MS(vap->iv_vhtcaps, 528 IEEE80211_VHTCAP_MU_BEAMFORMER_CAPABLE); 529 if (opmode == 1) 530 val2 = MS(ni->ni_vhtcap, 531 IEEE80211_VHTCAP_MU_BEAMFORMER_CAPABLE); 532 val = MIN(val1, val2); 533 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE) == 0) 534 val = 0; 535 if (opmode != 1) /* Only enable for STA mode */ 536 val = 0; 537 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 538 539 /* 540 * MU Beamformee capable - only if SU BFE capable, MU BFE capable 541 * and AP (not STA) 542 */ 543 val2 = val1 = MS(vap->iv_vhtcaps, 544 IEEE80211_VHTCAP_MU_BEAMFORMEE_CAPABLE); 545 if (opmode == 1) 546 val2 = MS(ni->ni_vhtcap, 547 IEEE80211_VHTCAP_MU_BEAMFORMEE_CAPABLE); 548 val = MIN(val1, val2); 549 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE) == 0) 550 val = 0; 551 if (opmode != 0) /* Only enable for AP mode */ 552 val = 0; 553 new_vhtcap |= SM(val, IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 554 555 /* VHT TXOP PS */ 556 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_VHT_TXOP_PS); 557 if (opmode == 1) 558 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_VHT_TXOP_PS); 559 val = MIN(val1, val2); 560 new_vhtcap |= SM(val, IEEE80211_VHTCAP_VHT_TXOP_PS); 561 562 /* HTC_VHT */ 563 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_HTC_VHT); 564 if (opmode == 1) 565 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_HTC_VHT); 566 val = MIN(val1, val2); 567 new_vhtcap |= SM(val, IEEE80211_VHTCAP_HTC_VHT); 568 569 /* A-MPDU length max */ 570 /* XXX TODO: we need a userland config knob for this */ 571 val2 = val1 = MS(vap->iv_vhtcaps, 572 IEEE80211_VHTCAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 573 if (opmode == 1) 574 val2 = MS(ni->ni_vhtcap, 575 IEEE80211_VHTCAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 576 val = MIN(val1, val2); 577 new_vhtcap |= SM(val, IEEE80211_VHTCAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 578 579 /* 580 * Link adaptation is only valid if HTC-VHT capable is 1. 581 * Otherwise, always set it to 0. 582 */ 583 val2 = val1 = MS(vap->iv_vhtcaps, 584 IEEE80211_VHTCAP_VHT_LINK_ADAPTATION_VHT_MASK); 585 if (opmode == 1) 586 val2 = MS(ni->ni_vhtcap, 587 IEEE80211_VHTCAP_VHT_LINK_ADAPTATION_VHT_MASK); 588 val = MIN(val1, val2); 589 if ((new_vhtcap & IEEE80211_VHTCAP_HTC_VHT) == 0) 590 val = 0; 591 new_vhtcap |= SM(val, IEEE80211_VHTCAP_VHT_LINK_ADAPTATION_VHT_MASK); 592 593 /* 594 * The following two options are 0 if the pattern may change, 1 if it 595 * does not change. So, downgrade to the higher value. 596 */ 597 598 /* RX antenna pattern */ 599 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_RX_ANTENNA_PATTERN); 600 if (opmode == 1) 601 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_RX_ANTENNA_PATTERN); 602 val = MAX(val1, val2); 603 new_vhtcap |= SM(val, IEEE80211_VHTCAP_RX_ANTENNA_PATTERN); 604 605 /* TX antenna pattern */ 606 val2 = val1 = MS(vap->iv_vhtcaps, IEEE80211_VHTCAP_TX_ANTENNA_PATTERN); 607 if (opmode == 1) 608 val2 = MS(ni->ni_vhtcap, IEEE80211_VHTCAP_TX_ANTENNA_PATTERN); 609 val = MAX(val1, val2); 610 new_vhtcap |= SM(val, IEEE80211_VHTCAP_TX_ANTENNA_PATTERN); 611 612 /* 613 * MCS set - again, we announce what we want to use 614 * based on configuration, device capabilities and 615 * already-learnt vhtcap/vhtinfo IE information. 616 */ 617 618 /* MCS set - start with whatever the device supports */ 619 vhtcap->supp_mcs.rx_mcs_map = vap->iv_vht_mcsinfo.rx_mcs_map; 620 vhtcap->supp_mcs.rx_highest = 0; 621 vhtcap->supp_mcs.tx_mcs_map = vap->iv_vht_mcsinfo.tx_mcs_map; 622 vhtcap->supp_mcs.tx_highest = 0; 623 624 vhtcap->vht_cap_info = new_vhtcap; 625 626 /* 627 * Now, if we're a STA, mask off whatever the AP doesn't support. 628 * Ie, we continue to state we can receive whatever we can do, 629 * but we only announce that we will transmit rates that meet 630 * the AP requirement. 631 * 632 * Note: 0 - MCS0..7; 1 - MCS0..8; 2 - MCS0..9; 3 = not supported. 633 * We can't just use MIN() because '3' means "no", so special case it. 634 */ 635 if (opmode) { 636 for (i = 0; i < 8; i++) { 637 val1 = (vhtcap->supp_mcs.tx_mcs_map >> (i*2)) & 0x3; 638 val2 = (ni->ni_vht_mcsinfo.tx_mcs_map >> (i*2)) & 0x3; 639 val = MIN(val1, val2); 640 if (val1 == 3 || val2 == 3) 641 val = 3; 642 vhtcap->supp_mcs.tx_mcs_map &= ~(0x3 << (i*2)); 643 vhtcap->supp_mcs.tx_mcs_map |= (val << (i*2)); 644 } 645 } 646 } 647 648 /* 649 * Add a VHTCAP field. 650 * 651 * If in station mode, we announce what we would like our 652 * desired configuration to be. 653 * 654 * Else, we announce our capabilities based on our current 655 * configuration. 656 */ 657 uint8_t * 658 ieee80211_add_vhtcap(uint8_t *frm, struct ieee80211_node *ni) 659 { 660 struct ieee80211_ie_vhtcap vhtcap; 661 int opmode; 662 663 opmode = 0; 664 if (ni->ni_vap->iv_opmode == IEEE80211_M_STA) 665 opmode = 1; 666 667 ieee80211_vht_get_vhtcap_ie(ni, &vhtcap, opmode); 668 669 memset(frm, '\0', sizeof(struct ieee80211_ie_vhtcap)); 670 671 frm[0] = IEEE80211_ELEMID_VHT_CAP; 672 frm[1] = sizeof(struct ieee80211_ie_vhtcap) - 2; 673 frm += 2; 674 675 /* 32-bit VHT capability */ 676 ADDWORD(frm, vhtcap.vht_cap_info); 677 678 /* suppmcs */ 679 ADDSHORT(frm, vhtcap.supp_mcs.rx_mcs_map); 680 ADDSHORT(frm, vhtcap.supp_mcs.rx_highest); 681 ADDSHORT(frm, vhtcap.supp_mcs.tx_mcs_map); 682 ADDSHORT(frm, vhtcap.supp_mcs.tx_highest); 683 684 return (frm); 685 } 686 687 static uint8_t 688 ieee80211_vht_get_chwidth_ie(struct ieee80211_channel *c) 689 { 690 691 /* 692 * XXX TODO: look at the node configuration as 693 * well? 694 */ 695 696 if (IEEE80211_IS_CHAN_VHT80P80(c)) 697 return IEEE80211_VHT_CHANWIDTH_80P80MHZ; 698 if (IEEE80211_IS_CHAN_VHT160(c)) 699 return IEEE80211_VHT_CHANWIDTH_160MHZ; 700 if (IEEE80211_IS_CHAN_VHT80(c)) 701 return IEEE80211_VHT_CHANWIDTH_80MHZ; 702 if (IEEE80211_IS_CHAN_VHT40(c)) 703 return IEEE80211_VHT_CHANWIDTH_USE_HT; 704 if (IEEE80211_IS_CHAN_VHT20(c)) 705 return IEEE80211_VHT_CHANWIDTH_USE_HT; 706 707 /* We shouldn't get here */ 708 printf("%s: called on a non-VHT channel (freq=%d, flags=0x%08x\n", 709 __func__, (int) c->ic_freq, c->ic_flags); 710 return IEEE80211_VHT_CHANWIDTH_USE_HT; 711 } 712 713 /* 714 * Note: this just uses the current channel information; 715 * it doesn't use the node info after parsing. 716 * 717 * XXX TODO: need to make the basic MCS set configurable. 718 * XXX TODO: read 802.11-2013 to determine what to set 719 * chwidth to when scanning. I have a feeling 720 * it isn't involved in scanning and we shouldn't 721 * be sending it; and I don't yet know what to set 722 * it to for IBSS or hostap where the peer may be 723 * a completely different channel width to us. 724 */ 725 uint8_t * 726 ieee80211_add_vhtinfo(uint8_t *frm, struct ieee80211_node *ni) 727 { 728 memset(frm, '\0', sizeof(struct ieee80211_ie_vht_operation)); 729 730 frm[0] = IEEE80211_ELEMID_VHT_OPMODE; 731 frm[1] = sizeof(struct ieee80211_ie_vht_operation) - 2; 732 frm += 2; 733 734 /* 8-bit chanwidth */ 735 *frm++ = ieee80211_vht_get_chwidth_ie(ni->ni_chan); 736 737 /* 8-bit freq1 */ 738 *frm++ = ni->ni_chan->ic_vht_ch_freq1; 739 740 /* 8-bit freq2 */ 741 *frm++ = ni->ni_chan->ic_vht_ch_freq2; 742 743 /* 16-bit basic MCS set - just MCS0..7 for NSS=1 for now */ 744 ADDSHORT(frm, 0xfffc); 745 746 return (frm); 747 } 748 749 void 750 ieee80211_vht_update_cap(struct ieee80211_node *ni, const uint8_t *vhtcap_ie, 751 const uint8_t *vhtop_ie) 752 { 753 754 ieee80211_parse_vhtcap(ni, vhtcap_ie); 755 ieee80211_parse_vhtopmode(ni, vhtop_ie); 756 } 757 758 static struct ieee80211_channel * 759 findvhtchan(struct ieee80211com *ic, struct ieee80211_channel *c, int vhtflags) 760 { 761 762 return (ieee80211_find_channel(ic, c->ic_freq, 763 (c->ic_flags & ~IEEE80211_CHAN_VHT) | vhtflags)); 764 } 765 766 /* 767 * Handle channel promotion to VHT, similar to ieee80211_ht_adjust_channel(). 768 */ 769 struct ieee80211_channel * 770 ieee80211_vht_adjust_channel(struct ieee80211com *ic, 771 struct ieee80211_channel *chan, int flags) 772 { 773 struct ieee80211_channel *c; 774 775 /* First case - handle channel demotion - if VHT isn't set */ 776 if ((flags & IEEE80211_FVHT_VHT) == 0) { 777 #if 0 778 printf("%s: demoting channel %d/0x%08x\n", __func__, 779 chan->ic_ieee, chan->ic_flags); 780 #endif 781 c = ieee80211_find_channel(ic, chan->ic_freq, 782 chan->ic_flags & ~IEEE80211_CHAN_VHT); 783 if (c == NULL) 784 c = chan; 785 #if 0 786 printf("%s: .. to %d/0x%08x\n", __func__, 787 c->ic_ieee, c->ic_flags); 788 #endif 789 return (c); 790 } 791 792 /* 793 * We can upgrade to VHT - attempt to do so 794 * 795 * Note: we don't clear the HT flags, these are the hints 796 * for HT40U/HT40D when selecting VHT40 or larger channels. 797 */ 798 /* Start with VHT80 */ 799 c = NULL; 800 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT160)) 801 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT80); 802 803 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT80P80)) 804 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT80P80); 805 806 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT80)) 807 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT80); 808 809 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT40)) 810 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT40U); 811 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT40)) 812 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT40D); 813 /* 814 * If we get here, VHT20 is always possible because we checked 815 * for IEEE80211_FVHT_VHT above. 816 */ 817 if (c == NULL) 818 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT20); 819 820 if (c != NULL) 821 chan = c; 822 823 #if 0 824 printf("%s: selected %d/0x%08x\n", __func__, c->ic_ieee, c->ic_flags); 825 #endif 826 return (chan); 827 } 828 829 /* 830 * Calculate the VHT operation IE for a given node. 831 * 832 * This includes calculating the suitable channel width/parameters 833 * and basic MCS set. 834 * 835 * TODO: ensure I read 9.7.11 Rate Selection for VHT STAs. 836 * TODO: ensure I read 10.39.7 - BSS Basic VHT-MCS and NSS set operation. 837 */ 838 void 839 ieee80211_vht_get_vhtinfo_ie(struct ieee80211_node *ni, 840 struct ieee80211_ie_vht_operation *vhtop, int opmode) 841 { 842 printf("%s: called; TODO!\n", __func__); 843 } 844