sys/net80211/ieee80211_vht.c

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