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 /* 27 * IEEE 802.11ac-2013 protocol support. 28 */ 29 30 #include "opt_inet.h" 31 #include "opt_wlan.h" 32 33 #include <sys/param.h> 34 #include <sys/kernel.h> 35 #include <sys/malloc.h> 36 #include <sys/systm.h> 37 #include <sys/endian.h> 38 39 #include <sys/socket.h> 40 41 #include <net/if.h> 42 #include <net/if_var.h> 43 #include <net/if_media.h> 44 #include <net/ethernet.h> 45 46 #include <net80211/ieee80211_var.h> 47 #include <net80211/ieee80211_action.h> 48 #include <net80211/ieee80211_input.h> 49 #include <net80211/ieee80211_vht.h> 50 51 #define ADDSHORT(frm, v) do { \ 52 frm[0] = (v) & 0xff; \ 53 frm[1] = (v) >> 8; \ 54 frm += 2; \ 55 } while (0) 56 #define ADDWORD(frm, v) do { \ 57 frm[0] = (v) & 0xff; \ 58 frm[1] = ((v) >> 8) & 0xff; \ 59 frm[2] = ((v) >> 16) & 0xff; \ 60 frm[3] = ((v) >> 24) & 0xff; \ 61 frm += 4; \ 62 } while (0) 63 64 /* 65 * Immediate TODO: 66 * 67 * + handle WLAN_ACTION_VHT_OPMODE_NOTIF and other VHT action frames 68 * + ensure vhtinfo/vhtcap parameters correctly use the negotiated 69 * capabilities and ratesets 70 * + group ID management operation 71 */ 72 73 /* 74 * XXX TODO: handle WLAN_ACTION_VHT_OPMODE_NOTIF 75 * 76 * Look at mac80211/vht.c:ieee80211_vht_handle_opmode() for further details. 77 */ 78 79 static int 80 vht_recv_action_placeholder(struct ieee80211_node *ni, 81 const struct ieee80211_frame *wh, 82 const uint8_t *frm, const uint8_t *efrm) 83 { 84 85 #ifdef IEEE80211_DEBUG 86 ieee80211_note(ni->ni_vap, "%s: called; fc=0x%.2x/0x%.2x", 87 __func__, wh->i_fc[0], wh->i_fc[1]); 88 #endif 89 return (0); 90 } 91 92 static int 93 vht_send_action_placeholder(struct ieee80211_node *ni, 94 int category, int action, void *arg0) 95 { 96 97 #ifdef IEEE80211_DEBUG 98 ieee80211_note(ni->ni_vap, "%s: called; category=%d, action=%d", 99 __func__, category, action); 100 #endif 101 return (EINVAL); 102 } 103 104 static void 105 ieee80211_vht_init(void) 106 { 107 108 ieee80211_recv_action_register(IEEE80211_ACTION_CAT_VHT, 109 WLAN_ACTION_VHT_COMPRESSED_BF, vht_recv_action_placeholder); 110 ieee80211_recv_action_register(IEEE80211_ACTION_CAT_VHT, 111 WLAN_ACTION_VHT_GROUPID_MGMT, vht_recv_action_placeholder); 112 ieee80211_recv_action_register(IEEE80211_ACTION_CAT_VHT, 113 WLAN_ACTION_VHT_OPMODE_NOTIF, vht_recv_action_placeholder); 114 115 ieee80211_send_action_register(IEEE80211_ACTION_CAT_VHT, 116 WLAN_ACTION_VHT_COMPRESSED_BF, vht_send_action_placeholder); 117 ieee80211_send_action_register(IEEE80211_ACTION_CAT_VHT, 118 WLAN_ACTION_VHT_GROUPID_MGMT, vht_send_action_placeholder); 119 ieee80211_send_action_register(IEEE80211_ACTION_CAT_VHT, 120 WLAN_ACTION_VHT_OPMODE_NOTIF, vht_send_action_placeholder); 121 } 122 123 SYSINIT(wlan_vht, SI_SUB_DRIVERS, SI_ORDER_FIRST, ieee80211_vht_init, NULL); 124 125 void 126 ieee80211_vht_attach(struct ieee80211com *ic) 127 { 128 } 129 130 void 131 ieee80211_vht_detach(struct ieee80211com *ic) 132 { 133 } 134 135 void 136 ieee80211_vht_vattach(struct ieee80211vap *vap) 137 { 138 struct ieee80211com *ic = vap->iv_ic; 139 140 if (! IEEE80211_CONF_VHT(ic)) 141 return; 142 143 vap->iv_vht_cap.vht_cap_info = ic->ic_vht_cap.vht_cap_info; 144 vap->iv_vhtextcaps = ic->ic_vhtextcaps; 145 146 /* XXX assume VHT80 support; should really check vhtcaps */ 147 vap->iv_vht_flags = 148 IEEE80211_FVHT_VHT 149 | IEEE80211_FVHT_USEVHT40 150 | IEEE80211_FVHT_USEVHT80; 151 if (IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_IS_160MHZ(vap->iv_vht_cap.vht_cap_info)) 152 vap->iv_vht_flags |= IEEE80211_FVHT_USEVHT160; 153 if (IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_IS_160_80P80MHZ(vap->iv_vht_cap.vht_cap_info)) 154 vap->iv_vht_flags |= IEEE80211_FVHT_USEVHT80P80; 155 156 memcpy(&vap->iv_vht_cap.supp_mcs, &ic->ic_vht_cap.supp_mcs, 157 sizeof(struct ieee80211_vht_mcs_info)); 158 } 159 160 void 161 ieee80211_vht_vdetach(struct ieee80211vap *vap) 162 { 163 } 164 165 #if 0 166 static void 167 vht_announce(struct ieee80211com *ic, enum ieee80211_phymode mode) 168 { 169 } 170 #endif 171 172 static int 173 vht_mcs_to_num(int m) 174 { 175 176 switch (m) { 177 case IEEE80211_VHT_MCS_SUPPORT_0_7: 178 return (7); 179 case IEEE80211_VHT_MCS_SUPPORT_0_8: 180 return (8); 181 case IEEE80211_VHT_MCS_SUPPORT_0_9: 182 return (9); 183 default: 184 return (0); 185 } 186 } 187 188 void 189 ieee80211_vht_announce(struct ieee80211com *ic) 190 { 191 int i, tx, rx; 192 193 if (! IEEE80211_CONF_VHT(ic)) 194 return; 195 196 /* Channel width */ 197 ic_printf(ic, "[VHT] Channel Widths: 20MHz, 40MHz, 80MHz%s%s\n", 198 (IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_IS_160MHZ(ic->ic_vht_cap.vht_cap_info)) ? 199 ", 160MHz" : "", 200 (IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_IS_160_80P80MHZ(ic->ic_vht_cap.vht_cap_info)) ? 201 ", 80+80MHz" : ""); 202 /* Features */ 203 ic_printf(ic, "[VHT] Features: %b\n", ic->ic_vht_cap.vht_cap_info, 204 IEEE80211_VHTCAP_BITS); 205 206 /* For now, just 5GHz VHT. Worry about 2GHz VHT later */ 207 for (i = 0; i < 8; i++) { 208 /* Each stream is 2 bits */ 209 tx = (ic->ic_vht_cap.supp_mcs.tx_mcs_map >> (2*i)) & 0x3; 210 rx = (ic->ic_vht_cap.supp_mcs.rx_mcs_map >> (2*i)) & 0x3; 211 if (tx == 3 && rx == 3) 212 continue; 213 ic_printf(ic, "[VHT] NSS %d: TX MCS 0..%d, RX MCS 0..%d\n", 214 i + 1, vht_mcs_to_num(tx), vht_mcs_to_num(rx)); 215 } 216 } 217 218 void 219 ieee80211_vht_node_init(struct ieee80211_node *ni) 220 { 221 222 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 223 "%s: called", __func__); 224 ni->ni_flags |= IEEE80211_NODE_VHT; 225 } 226 227 void 228 ieee80211_vht_node_cleanup(struct ieee80211_node *ni) 229 { 230 231 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 232 "%s: called", __func__); 233 ni->ni_flags &= ~IEEE80211_NODE_VHT; 234 ni->ni_vhtcap = 0; 235 bzero(&ni->ni_vht_mcsinfo, sizeof(struct ieee80211_vht_mcs_info)); 236 } 237 238 /* 239 * Parse an 802.11ac VHT operation IE. 240 * 241 * 802.11-2020 9.4.2.158 (VHT Operation element) 242 */ 243 void 244 ieee80211_parse_vhtopmode(struct ieee80211_node *ni, const uint8_t *ie) 245 { 246 /* vht operation */ 247 ni->ni_vht_chanwidth = ie[2]; 248 ni->ni_vht_chan1 = ie[3]; 249 ni->ni_vht_chan2 = ie[4]; 250 ni->ni_vht_basicmcs = le16dec(ie + 5); 251 252 #if 0 253 net80211_vap_printf(ni->ni_vap, 254 "%s: chan1=%d, chan2=%d, chanwidth=%d, basicmcs=0x%04x\n", 255 __func__, ni->ni_vht_chan1, ni->ni_vht_chan2, ni->ni_vht_chanwidth, 256 ni->ni_vht_basicmcs); 257 #endif 258 } 259 260 /* 261 * Parse an 802.11ac VHT capability IE. 262 * 263 * 802.11-2020 9.4.2.157 (VHT Capabilities element) 264 */ 265 void 266 ieee80211_parse_vhtcap(struct ieee80211_node *ni, const uint8_t *ie) 267 { 268 269 /* vht capability */ 270 ni->ni_vhtcap = le32dec(ie + 2); 271 272 /* suppmcs */ 273 ni->ni_vht_mcsinfo.rx_mcs_map = le16dec(ie + 6); 274 ni->ni_vht_mcsinfo.rx_highest = le16dec(ie + 8); 275 ni->ni_vht_mcsinfo.tx_mcs_map = le16dec(ie + 10); 276 ni->ni_vht_mcsinfo.tx_highest = le16dec(ie + 12); 277 } 278 279 int 280 ieee80211_vht_updateparams(struct ieee80211_node *ni, 281 const uint8_t *vhtcap_ie, 282 const uint8_t *vhtop_ie) 283 { 284 285 //printf("%s: called\n", __func__); 286 287 ieee80211_parse_vhtcap(ni, vhtcap_ie); 288 ieee80211_parse_vhtopmode(ni, vhtop_ie); 289 return (0); 290 } 291 292 /** 293 * @brief calculate the supported MCS rates for this node 294 * 295 * This is called once a node has finished association / 296 * joined a BSS. The vhtcap / vhtop IEs are from the 297 * peer. The transmit rate tables need to be combined 298 * together to setup the list of available rates. 299 * 300 * This must be called after the ieee80211_node VHT fields 301 * have been parsed / populated by either ieee80211_vht_updateparams() or 302 * ieee80211_parse_vhtcap(), 303 * 304 * This does not take into account the channel bandwidth, 305 * which (a) may change during operation, and (b) depends 306 * upon packet to packet rate transmission selection. 307 * There are various rate combinations which are not 308 * available in various channel widths and those will 309 * need to be masked off separately. 310 * 311 * (See 802.11-2020 21.5 Parameters for VHT-MCSs for the 312 * tables and supported rates.) 313 * 314 * ALSO: i need to do some filtering based on the HT set too. 315 * (That should be done here too, and in the negotiation, sigh.) 316 * (See 802.11-2016 10.7.12.3 Additional rate selection constraints 317 * for VHT PPDUs) 318 * 319 * @param ni struct ieee80211_node to configure 320 */ 321 void 322 ieee80211_setup_vht_rates(struct ieee80211_node *ni) 323 { 324 struct ieee80211vap *vap = ni->ni_vap; 325 uint32_t val, val1, val2; 326 uint16_t tx_mcs_map = 0; 327 int i; 328 329 /* 330 * Merge our tx_mcs_map with the peer rx_mcs_map to determine what 331 * can be actually transmitted to the peer. 332 */ 333 334 for (i = 0; i < 8; i++) { 335 /* 336 * Merge the two together; remember that 0..2 is in order 337 * of increasing MCS support, but 3 equals 338 * IEEE80211_VHT_MCS_NOT_SUPPORTED so must "win". 339 */ 340 val1 = (vap->iv_vht_cap.supp_mcs.tx_mcs_map >> (i*2)) & 0x3; 341 val2 = (ni->ni_vht_mcsinfo.rx_mcs_map >> (i*2)) & 0x3; 342 val = MIN(val1, val2); 343 if (val1 == IEEE80211_VHT_MCS_NOT_SUPPORTED || 344 val2 == IEEE80211_VHT_MCS_NOT_SUPPORTED) 345 val = IEEE80211_VHT_MCS_NOT_SUPPORTED; 346 tx_mcs_map |= (val << (i*2)); 347 } 348 349 /* Store the TX MCS map somewhere in the node that can be used */ 350 ni->ni_vht_tx_map = tx_mcs_map; 351 } 352 353 void 354 ieee80211_vht_timeout(struct ieee80211vap *vap) 355 { 356 } 357 358 void 359 ieee80211_vht_node_join(struct ieee80211_node *ni) 360 { 361 362 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 363 "%s: called", __func__); 364 } 365 366 void 367 ieee80211_vht_node_leave(struct ieee80211_node *ni) 368 { 369 370 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_11N, ni, 371 "%s: called", __func__); 372 } 373 374 /* 375 * Calculate the VHTCAP IE for a given node. 376 * 377 * This includes calculating the capability intersection based on the 378 * current operating mode and intersection of the TX/RX MCS maps. 379 * 380 * The standard only makes it clear about MCS rate negotiation 381 * and MCS basic rates (which must be a subset of the general 382 * negotiated rates). It doesn't make it clear that the AP should 383 * figure out the minimum functional overlap with the STA and 384 * support that. 385 * 386 * Note: this is in host order, not in 802.11 endian order. 387 * 388 * TODO: ensure I re-read 9.7.11 Rate Selection for VHT STAs. 389 * 390 * TODO: investigate what we should negotiate for MU-MIMO beamforming 391 * options. 392 * 393 * opmode is '1' for "vhtcap as if I'm a STA", 0 otherwise. 394 */ 395 void 396 ieee80211_vht_get_vhtcap_ie(struct ieee80211_node *ni, 397 struct ieee80211_vht_cap *vhtcap, int opmode) 398 { 399 struct ieee80211vap *vap = ni->ni_vap; 400 // struct ieee80211com *ic = vap->iv_ic; 401 uint32_t val, val1, val2; 402 uint32_t new_vhtcap; 403 int i; 404 405 /* 406 * Capabilities - it depends on whether we are a station 407 * or not. 408 */ 409 new_vhtcap = 0; 410 411 /* 412 * Station - use our desired configuration based on 413 * local config, local device bits and the already-learnt 414 * vhtcap/vhtinfo IE in the node. 415 */ 416 417 /* Limit MPDU size to the smaller of the two */ 418 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 419 IEEE80211_VHTCAP_MAX_MPDU_MASK); 420 if (opmode == 1) { 421 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 422 IEEE80211_VHTCAP_MAX_MPDU_MASK); 423 } 424 val = MIN(val1, val2); 425 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_MAX_MPDU_MASK); 426 427 /* Limit supp channel config */ 428 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 429 IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK); 430 if (opmode == 1) { 431 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 432 IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK); 433 } 434 if ((val2 == 2) && 435 ((vap->iv_vht_flags & IEEE80211_FVHT_USEVHT80P80) == 0)) 436 val2 = 1; 437 if ((val2 == 1) && 438 ((vap->iv_vht_flags & IEEE80211_FVHT_USEVHT160) == 0)) 439 val2 = 0; 440 val = MIN(val1, val2); 441 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 442 IEEE80211_VHTCAP_SUPP_CHAN_WIDTH_MASK); 443 444 /* RX LDPC */ 445 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 446 IEEE80211_VHTCAP_RXLDPC); 447 if (opmode == 1) { 448 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 449 IEEE80211_VHTCAP_RXLDPC); 450 } 451 val = MIN(val1, val2); 452 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_RXLDPC); 453 454 /* Short-GI 80 */ 455 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 456 IEEE80211_VHTCAP_SHORT_GI_80); 457 if (opmode == 1) { 458 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 459 IEEE80211_VHTCAP_SHORT_GI_80); 460 } 461 val = MIN(val1, val2); 462 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_SHORT_GI_80); 463 464 /* Short-GI 160 */ 465 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 466 IEEE80211_VHTCAP_SHORT_GI_160); 467 if (opmode == 1) { 468 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 469 IEEE80211_VHTCAP_SHORT_GI_160); 470 } 471 val = MIN(val1, val2); 472 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_SHORT_GI_160); 473 474 /* 475 * STBC is slightly more complicated. 476 * 477 * In non-STA mode, we just announce our capabilities and that 478 * is that. 479 * 480 * In STA mode, we should calculate our capabilities based on 481 * local capabilities /and/ what the remote says. So: 482 * 483 * + Only TX STBC if we support it and the remote supports RX STBC; 484 * + Only announce RX STBC if we support it and the remote supports 485 * TX STBC; 486 * + RX STBC should be the minimum of local and remote RX STBC; 487 */ 488 489 /* TX STBC */ 490 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 491 IEEE80211_VHTCAP_TXSTBC); 492 if (opmode == 1) { 493 /* STA mode - enable it only if node RXSTBC is non-zero */ 494 val2 = !! _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 495 IEEE80211_VHTCAP_RXSTBC_MASK); 496 } 497 val = MIN(val1, val2); 498 if ((vap->iv_vht_flags & IEEE80211_FVHT_STBC_TX) == 0) 499 val = 0; 500 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_TXSTBC); 501 502 /* RX STBC1..4 */ 503 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 504 IEEE80211_VHTCAP_RXSTBC_MASK); 505 if (opmode == 1) { 506 /* STA mode - enable it only if node TXSTBC is non-zero */ 507 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 508 IEEE80211_VHTCAP_TXSTBC); 509 } 510 val = MIN(val1, val2); 511 if ((vap->iv_vht_flags & IEEE80211_FVHT_STBC_RX) == 0) 512 val = 0; 513 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_RXSTBC_MASK); 514 515 /* 516 * Finally - if RXSTBC is 0, then don't enable TXSTBC. 517 * Strictly speaking a device can TXSTBC and not RXSTBC, but 518 * it would be silly. 519 */ 520 if (val == 0) 521 new_vhtcap &= ~IEEE80211_VHTCAP_TXSTBC; 522 523 /* 524 * Some of these fields require other fields to exist. 525 * So before using it, the parent field needs to be checked 526 * otherwise the overridden value may be wrong. 527 * 528 * For example, if SU beamformee is set to 0, then BF STS 529 * needs to be 0. 530 */ 531 532 /* SU Beamformer capable */ 533 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 534 IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 535 if (opmode == 1) { 536 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 537 IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 538 } 539 val = MIN(val1, val2); 540 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 541 IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 542 543 /* SU Beamformee capable */ 544 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 545 IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 546 if (opmode == 1) { 547 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 548 IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 549 } 550 val = MIN(val1, val2); 551 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 552 IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 553 554 /* Beamformee STS capability - only if SU beamformee capable */ 555 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 556 IEEE80211_VHTCAP_BEAMFORMEE_STS_MASK); 557 if (opmode == 1) { 558 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 559 IEEE80211_VHTCAP_BEAMFORMEE_STS_MASK); 560 } 561 val = MIN(val1, val2); 562 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE) == 0) 563 val = 0; 564 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 565 IEEE80211_VHTCAP_BEAMFORMEE_STS_MASK); 566 567 /* Sounding dimensions - only if SU beamformer capable */ 568 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 569 IEEE80211_VHTCAP_SOUNDING_DIMENSIONS_MASK); 570 if (opmode == 1) 571 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 572 IEEE80211_VHTCAP_SOUNDING_DIMENSIONS_MASK); 573 val = MIN(val1, val2); 574 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE) == 0) 575 val = 0; 576 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 577 IEEE80211_VHTCAP_SOUNDING_DIMENSIONS_MASK); 578 579 /* 580 * MU Beamformer capable - only if SU BFF capable, MU BFF capable 581 * and STA (not AP) 582 */ 583 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 584 IEEE80211_VHTCAP_MU_BEAMFORMER_CAPABLE); 585 if (opmode == 1) 586 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 587 IEEE80211_VHTCAP_MU_BEAMFORMER_CAPABLE); 588 val = MIN(val1, val2); 589 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE) == 0) 590 val = 0; 591 if (opmode != 1) /* Only enable for STA mode */ 592 val = 0; 593 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 594 IEEE80211_VHTCAP_SU_BEAMFORMER_CAPABLE); 595 596 /* 597 * MU Beamformee capable - only if SU BFE capable, MU BFE capable 598 * and AP (not STA) 599 */ 600 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 601 IEEE80211_VHTCAP_MU_BEAMFORMEE_CAPABLE); 602 if (opmode == 1) 603 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 604 IEEE80211_VHTCAP_MU_BEAMFORMEE_CAPABLE); 605 val = MIN(val1, val2); 606 if ((new_vhtcap & IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE) == 0) 607 val = 0; 608 if (opmode != 0) /* Only enable for AP mode */ 609 val = 0; 610 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 611 IEEE80211_VHTCAP_SU_BEAMFORMEE_CAPABLE); 612 613 /* VHT TXOP PS */ 614 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 615 IEEE80211_VHTCAP_VHT_TXOP_PS); 616 if (opmode == 1) 617 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 618 IEEE80211_VHTCAP_VHT_TXOP_PS); 619 val = MIN(val1, val2); 620 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_VHT_TXOP_PS); 621 622 /* HTC_VHT */ 623 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 624 IEEE80211_VHTCAP_HTC_VHT); 625 if (opmode == 1) 626 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 627 IEEE80211_VHTCAP_HTC_VHT); 628 val = MIN(val1, val2); 629 new_vhtcap |= _IEEE80211_SHIFTMASK(val, IEEE80211_VHTCAP_HTC_VHT); 630 631 /* A-MPDU length max */ 632 /* XXX TODO: we need a userland config knob for this */ 633 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 634 IEEE80211_VHTCAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 635 if (opmode == 1) 636 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 637 IEEE80211_VHTCAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 638 val = MIN(val1, val2); 639 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 640 IEEE80211_VHTCAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK); 641 642 /* 643 * Link adaptation is only valid if HTC-VHT capable is 1. 644 * Otherwise, always set it to 0. 645 */ 646 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 647 IEEE80211_VHTCAP_VHT_LINK_ADAPTATION_VHT_MASK); 648 if (opmode == 1) 649 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 650 IEEE80211_VHTCAP_VHT_LINK_ADAPTATION_VHT_MASK); 651 val = MIN(val1, val2); 652 if ((new_vhtcap & IEEE80211_VHTCAP_HTC_VHT) == 0) 653 val = 0; 654 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 655 IEEE80211_VHTCAP_VHT_LINK_ADAPTATION_VHT_MASK); 656 657 /* 658 * The following two options are 0 if the pattern may change, 1 if it 659 * does not change. So, downgrade to the higher value. 660 */ 661 662 /* RX antenna pattern */ 663 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 664 IEEE80211_VHTCAP_RX_ANTENNA_PATTERN); 665 if (opmode == 1) 666 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 667 IEEE80211_VHTCAP_RX_ANTENNA_PATTERN); 668 val = MAX(val1, val2); 669 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 670 IEEE80211_VHTCAP_RX_ANTENNA_PATTERN); 671 672 /* TX antenna pattern */ 673 val2 = val1 = _IEEE80211_MASKSHIFT(vap->iv_vht_cap.vht_cap_info, 674 IEEE80211_VHTCAP_TX_ANTENNA_PATTERN); 675 if (opmode == 1) 676 val2 = _IEEE80211_MASKSHIFT(ni->ni_vhtcap, 677 IEEE80211_VHTCAP_TX_ANTENNA_PATTERN); 678 val = MAX(val1, val2); 679 new_vhtcap |= _IEEE80211_SHIFTMASK(val, 680 IEEE80211_VHTCAP_TX_ANTENNA_PATTERN); 681 682 /* 683 * MCS set - again, we announce what we want to use 684 * based on configuration, device capabilities and 685 * already-learnt vhtcap/vhtinfo IE information. 686 */ 687 688 /* MCS set - start with whatever the device supports */ 689 vhtcap->supp_mcs.rx_mcs_map = vap->iv_vht_cap.supp_mcs.rx_mcs_map; 690 vhtcap->supp_mcs.rx_highest = 0; 691 vhtcap->supp_mcs.tx_mcs_map = vap->iv_vht_cap.supp_mcs.tx_mcs_map; 692 vhtcap->supp_mcs.tx_highest = 0; 693 694 vhtcap->vht_cap_info = new_vhtcap; 695 696 /* 697 * Now, if we're a STA, mask off whatever the AP doesn't support. 698 * Ie, we continue to state we can receive whatever we can do, 699 * but we only announce that we will transmit rates that meet 700 * the AP requirement. 701 * 702 * Note: 0 - MCS0..7; 1 - MCS0..8; 2 - MCS0..9; 3 = not supported. 703 * We can't just use MIN() because '3' means "no", so special case it. 704 */ 705 if (opmode) { 706 for (i = 0; i < 8; i++) { 707 val1 = (vhtcap->supp_mcs.tx_mcs_map >> (i*2)) & 0x3; 708 val2 = (ni->ni_vht_mcsinfo.tx_mcs_map >> (i*2)) & 0x3; 709 val = MIN(val1, val2); 710 if (val1 == 3 || val2 == 3) 711 val = 3; 712 vhtcap->supp_mcs.tx_mcs_map &= ~(0x3 << (i*2)); 713 vhtcap->supp_mcs.tx_mcs_map |= (val << (i*2)); 714 } 715 } 716 } 717 718 /* 719 * Add a VHTCAP field. 720 * 721 * If in station mode, we announce what we would like our 722 * desired configuration to be. 723 * 724 * Else, we announce our capabilities based on our current 725 * configuration. 726 */ 727 uint8_t * 728 ieee80211_add_vhtcap(uint8_t *frm, struct ieee80211_node *ni) 729 { 730 struct ieee80211_vht_cap vhtcap; 731 732 ieee80211_vht_get_vhtcap_ie(ni, &vhtcap, 1); 733 734 frm[0] = IEEE80211_ELEMID_VHT_CAP; 735 frm[1] = sizeof(vhtcap); 736 frm += 2; 737 738 /* 32-bit VHT capability */ 739 ADDWORD(frm, vhtcap.vht_cap_info); 740 741 /* suppmcs */ 742 ADDSHORT(frm, vhtcap.supp_mcs.rx_mcs_map); 743 ADDSHORT(frm, vhtcap.supp_mcs.rx_highest); 744 ADDSHORT(frm, vhtcap.supp_mcs.tx_mcs_map); 745 ADDSHORT(frm, vhtcap.supp_mcs.tx_highest); 746 747 return (frm); 748 } 749 750 /* 751 * Non-associated probe requests. Add VHT capabilities based on 752 * the current channel configuration. No BSS yet. 753 */ 754 uint8_t * 755 ieee80211_add_vhtcap_ch(uint8_t *frm, struct ieee80211vap *vap, 756 struct ieee80211_channel *c) 757 { 758 struct ieee80211_vht_cap *vhtcap; 759 760 memset(frm, 0, 2 + sizeof(*vhtcap)); 761 frm[0] = IEEE80211_ELEMID_VHT_CAP; 762 frm[1] = sizeof(*vhtcap); 763 frm += 2; 764 765 /* 32-bit VHT capability */ 766 ADDWORD(frm, vap->iv_vht_cap.vht_cap_info); 767 768 /* supp_mcs */ 769 ADDSHORT(frm, vap->iv_vht_cap.supp_mcs.rx_mcs_map); 770 ADDSHORT(frm, vap->iv_vht_cap.supp_mcs.rx_highest); 771 ADDSHORT(frm, vap->iv_vht_cap.supp_mcs.tx_mcs_map); 772 ADDSHORT(frm, vap->iv_vht_cap.supp_mcs.tx_highest); 773 774 return (frm); 775 } 776 777 static uint8_t 778 ieee80211_vht_get_chwidth_ie(const struct ieee80211vap *vap, 779 const struct ieee80211_channel *c) 780 { 781 782 /* 783 * XXX TODO: look at the node configuration as 784 * well? 785 */ 786 787 if (IEEE80211_IS_CHAN_VHT80P80(c)) 788 return IEEE80211_VHT_CHANWIDTH_80P80MHZ; 789 if (IEEE80211_IS_CHAN_VHT160(c)) 790 return IEEE80211_VHT_CHANWIDTH_160MHZ; 791 if (IEEE80211_IS_CHAN_VHT80(c)) 792 return IEEE80211_VHT_CHANWIDTH_80MHZ; 793 if (IEEE80211_IS_CHAN_VHT40(c)) 794 return IEEE80211_VHT_CHANWIDTH_USE_HT; 795 if (IEEE80211_IS_CHAN_VHT20(c)) 796 return IEEE80211_VHT_CHANWIDTH_USE_HT; 797 798 /* We shouldn't get here */ 799 net80211_vap_printf(vap, 800 "%s: called on a non-VHT channel (freq=%d, flags=0x%08x\n", 801 __func__, (int) c->ic_freq, c->ic_flags); 802 return IEEE80211_VHT_CHANWIDTH_USE_HT; 803 } 804 805 /* 806 * Note: this just uses the current channel information; 807 * it doesn't use the node info after parsing. 808 * 809 * XXX TODO: need to make the basic MCS set configurable. 810 * XXX TODO: read 802.11-2013 to determine what to set 811 * chwidth to when scanning. I have a feeling 812 * it isn't involved in scanning and we shouldn't 813 * be sending it; and I don't yet know what to set 814 * it to for IBSS or hostap where the peer may be 815 * a completely different channel width to us. 816 */ 817 uint8_t * 818 ieee80211_add_vhtinfo(uint8_t *frm, struct ieee80211_node *ni) 819 { 820 821 frm[0] = IEEE80211_ELEMID_VHT_OPMODE; 822 frm[1] = sizeof(struct ieee80211_vht_operation); 823 frm += 2; 824 825 /* 8-bit chanwidth */ 826 *frm++ = ieee80211_vht_get_chwidth_ie(ni->ni_vap, ni->ni_chan); 827 828 /* 8-bit freq1 */ 829 *frm++ = ni->ni_chan->ic_vht_ch_freq1; 830 831 /* 8-bit freq2 */ 832 *frm++ = ni->ni_chan->ic_vht_ch_freq2; 833 834 /* 16-bit basic MCS set - just MCS0..7 for NSS=1 for now */ 835 ADDSHORT(frm, 0xfffc); 836 837 return (frm); 838 } 839 840 void 841 ieee80211_vht_update_cap(struct ieee80211_node *ni, const uint8_t *vhtcap_ie, 842 const uint8_t *vhtop_ie) 843 { 844 845 ieee80211_parse_vhtcap(ni, vhtcap_ie); 846 ieee80211_parse_vhtopmode(ni, vhtop_ie); 847 } 848 849 static struct ieee80211_channel * 850 findvhtchan(struct ieee80211com *ic, struct ieee80211_channel *c, int vhtflags) 851 { 852 853 return (ieee80211_find_channel(ic, c->ic_freq, 854 (c->ic_flags & ~IEEE80211_CHAN_VHT) | vhtflags)); 855 } 856 857 /* 858 * Handle channel promotion to VHT, similar to ieee80211_ht_adjust_channel(). 859 */ 860 struct ieee80211_channel * 861 ieee80211_vht_adjust_channel(struct ieee80211com *ic, 862 struct ieee80211_channel *chan, int flags) 863 { 864 struct ieee80211_channel *c; 865 866 /* First case - handle channel demotion - if VHT isn't set */ 867 if ((flags & IEEE80211_FVHT_MASK) == 0) { 868 #if 0 869 net80211_ic_printf(ic, 870 "%s: demoting channel %d/0x%08x\n", __func__, 871 chan->ic_ieee, chan->ic_flags); 872 #endif 873 c = ieee80211_find_channel(ic, chan->ic_freq, 874 chan->ic_flags & ~IEEE80211_CHAN_VHT); 875 if (c == NULL) 876 c = chan; 877 #if 0 878 net80211_ic_printf(ic, "%s: .. to %d/0x%08x\n", __func__, 879 c->ic_ieee, c->ic_flags); 880 #endif 881 return (c); 882 } 883 884 /* 885 * We can upgrade to VHT - attempt to do so 886 * 887 * Note: we don't clear the HT flags, these are the hints 888 * for HT40U/HT40D when selecting VHT40 or larger channels. 889 */ 890 c = NULL; 891 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT160)) 892 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT160); 893 894 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT80P80)) 895 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT80P80); 896 897 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT80)) 898 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT80); 899 900 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT40)) 901 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT40U); 902 if ((c == NULL) && (flags & IEEE80211_FVHT_USEVHT40)) 903 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT40D); 904 /* 905 * If we get here, VHT20 is always possible because we checked 906 * for IEEE80211_FVHT_VHT above. 907 */ 908 if (c == NULL) 909 c = findvhtchan(ic, chan, IEEE80211_CHAN_VHT20); 910 911 if (c != NULL) 912 chan = c; 913 914 #if 0 915 net80211_ic_printf(ic, "%s: selected %d/0x%08x\n", __func__, 916 c->ic_ieee, c->ic_flags); 917 #endif 918 return (chan); 919 } 920 921 /* 922 * Calculate the VHT operation IE for a given node. 923 * 924 * This includes calculating the suitable channel width/parameters 925 * and basic MCS set. 926 * 927 * TODO: ensure I read 9.7.11 Rate Selection for VHT STAs. 928 * TODO: ensure I read 10.39.7 - BSS Basic VHT-MCS and NSS set operation. 929 */ 930 void 931 ieee80211_vht_get_vhtinfo_ie(struct ieee80211_node *ni, 932 struct ieee80211_vht_operation *vhtop, int opmode) 933 { 934 net80211_vap_printf(ni->ni_vap, "%s: called; TODO!\n", __func__); 935 } 936 937 /* 938 * Return true if VHT rates can be used for the given node. 939 */ 940 bool 941 ieee80211_vht_check_tx_vht(const struct ieee80211_node *ni) 942 { 943 const struct ieee80211vap *vap; 944 const struct ieee80211_channel *bss_chan; 945 946 if (ni == NULL || ni->ni_chan == IEEE80211_CHAN_ANYC || 947 ni->ni_vap == NULL || ni->ni_vap->iv_bss == NULL) 948 return (false); 949 950 vap = ni->ni_vap; 951 bss_chan = vap->iv_bss->ni_chan; 952 953 if (bss_chan == IEEE80211_CHAN_ANYC) 954 return (false); 955 956 return (IEEE80211_IS_CHAN_VHT(ni->ni_chan)); 957 } 958 959 /* 960 * Return true if VHT40 rates can be transmitted to the given node. 961 * 962 * This verifies that the BSS is VHT40 capable and the current 963 * node channel width is 40MHz. 964 */ 965 static bool 966 ieee80211_vht_check_tx_vht40(const struct ieee80211_node *ni) 967 { 968 struct ieee80211vap *vap; 969 struct ieee80211_channel *bss_chan; 970 971 if (!ieee80211_vht_check_tx_vht(ni)) 972 return (false); 973 974 vap = ni->ni_vap; 975 bss_chan = vap->iv_bss->ni_chan; 976 977 return (IEEE80211_IS_CHAN_VHT40(bss_chan) && 978 IEEE80211_IS_CHAN_VHT40(ni->ni_chan) && 979 (ni->ni_chw == IEEE80211_STA_RX_BW_40)); 980 } 981 982 /* 983 * Return true if VHT80 rates can be transmitted to the given node. 984 * 985 * This verifies that the BSS is VHT80 capable and the current 986 * node channel width is 80MHz. 987 */ 988 static bool 989 ieee80211_vht_check_tx_vht80(const struct ieee80211_node *ni) 990 { 991 struct ieee80211vap *vap; 992 struct ieee80211_channel *bss_chan; 993 994 if (!ieee80211_vht_check_tx_vht(ni)) 995 return (false); 996 997 vap = ni->ni_vap; 998 bss_chan = vap->iv_bss->ni_chan; 999 1000 /* 1001 * ni_chw represents 20MHz or 40MHz from the HT 1002 * TX width action frame / HT channel negotiation. 1003 * If a HT TX width action frame sets it to 20MHz 1004 * then reject doing 80MHz. 1005 */ 1006 return (IEEE80211_IS_CHAN_VHT80(bss_chan) && 1007 IEEE80211_IS_CHAN_VHT80(ni->ni_chan) && 1008 (ni->ni_chw != IEEE80211_STA_RX_BW_20)); 1009 } 1010 1011 /* 1012 * Return true if VHT 160 rates can be transmitted to the given node. 1013 * 1014 * This verifies that the BSS is VHT80+80 or VHT160 capable and the current 1015 * node channel width is 80+80MHz or 160MHz. 1016 */ 1017 static bool 1018 ieee80211_vht_check_tx_vht160(const struct ieee80211_node *ni) 1019 { 1020 struct ieee80211vap *vap; 1021 struct ieee80211_channel *bss_chan; 1022 1023 if (!ieee80211_vht_check_tx_vht(ni)) 1024 return (false); 1025 1026 vap = ni->ni_vap; 1027 bss_chan = vap->iv_bss->ni_chan; 1028 1029 /* 1030 * ni_chw represents 20MHz or 40MHz from the HT 1031 * TX width action frame / HT channel negotiation. 1032 * If a HT TX width action frame sets it to 20MHz 1033 * then reject doing 160MHz. 1034 */ 1035 if (ni->ni_chw == IEEE80211_STA_RX_BW_20) 1036 return (false); 1037 1038 if (IEEE80211_IS_CHAN_VHT160(bss_chan) && 1039 IEEE80211_IS_CHAN_VHT160(ni->ni_chan)) 1040 return (true); 1041 1042 if (IEEE80211_IS_CHAN_VHT80P80(bss_chan) && 1043 IEEE80211_IS_CHAN_VHT80P80(ni->ni_chan)) 1044 return (true); 1045 1046 return (false); 1047 } 1048 1049 /** 1050 * @brief Check if the given transmit bandwidth is available to the given node 1051 * 1052 * This checks that the node and BSS both allow the given bandwidth, 1053 * and that the current node bandwidth (which can dynamically change) 1054 * also allows said bandwidth. 1055 * 1056 * This relies on the channels having the flags for the narrower 1057 * channels as well - eg a VHT160 channel will have the CHAN_VHT80, 1058 * CHAN_VHT40, CHAN_VHT flags also set. 1059 * 1060 * @param ni the ieee80211_node to check 1061 * @param bw the required bandwidth to check 1062 * 1063 * @returns true if it is allowed, false otherwise 1064 */ 1065 bool 1066 ieee80211_vht_check_tx_bw(const struct ieee80211_node *ni, 1067 enum ieee80211_sta_rx_bw bw) 1068 { 1069 1070 switch (bw) { 1071 case IEEE80211_STA_RX_BW_20: 1072 return (ieee80211_vht_check_tx_vht(ni)); 1073 case IEEE80211_STA_RX_BW_40: 1074 return (ieee80211_vht_check_tx_vht40(ni)); 1075 case IEEE80211_STA_RX_BW_80: 1076 return (ieee80211_vht_check_tx_vht80(ni)); 1077 case IEEE80211_STA_RX_BW_160: 1078 return (ieee80211_vht_check_tx_vht160(ni)); 1079 case IEEE80211_STA_RX_BW_320: 1080 return (false); 1081 default: 1082 return (false); 1083 } 1084 } 1085 1086 /** 1087 * @brief Check if the given VHT bw/nss/mcs combination is valid 1088 * for the give node. 1089 * 1090 * This checks whether the given VHT bw/nss/mcs is valid based on 1091 * the negotiated rate mask in the node. 1092 * 1093 * @param ni struct ieee80211_node node to check 1094 * @param bw channel bandwidth to check 1095 * @param nss NSS 1096 * @param mcs MCS 1097 * @returns True if this combination is available, false otherwise. 1098 */ 1099 bool 1100 ieee80211_vht_node_check_tx_valid_mcs(const struct ieee80211_node *ni, 1101 enum ieee80211_sta_rx_bw bw, uint8_t nss, uint8_t mcs) 1102 { 1103 uint8_t mc; 1104 1105 /* Validate arguments */ 1106 if (nss < 1 || nss > 8) 1107 return (false); 1108 if (mcs > 9) 1109 return (false); 1110 1111 /* Check our choice of rate is actually valid */ 1112 if (!ieee80211_phy_vht_validate_mcs(bw, nss, mcs)) 1113 return (false); 1114 1115 /* 1116 * Next, check if the MCS rate is available for the 1117 * given NSS. 1118 */ 1119 mc = ni->ni_vht_tx_map >> (2*(nss-1)) & 0x3; 1120 switch (mc) { 1121 case IEEE80211_VHT_MCS_NOT_SUPPORTED: 1122 /* Not supported at this NSS */ 1123 return (false); 1124 case IEEE80211_VHT_MCS_SUPPORT_0_9: 1125 return (mcs <= 9); 1126 case IEEE80211_VHT_MCS_SUPPORT_0_8: 1127 return (mcs <= 8); 1128 case IEEE80211_VHT_MCS_SUPPORT_0_7: 1129 return (mcs <= 7); 1130 default: 1131 return (false); 1132 } 1133 } 1134