xref: /freebsd/sys/net80211/ieee80211_vht.c (revision 9e5787d2284e187abb5b654d924394a65772e004)
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