projects/linux·blob master · refs

494 lines · 15.2 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * VHT handling
4 *
5 * Portions of this file
6 * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
7 * Copyright (C) 2018 - 2026 Intel Corporation
8 */
9
10#include <linux/ieee80211.h>
11#include <linux/export.h>
12#include <net/mac80211.h>
13#include "ieee80211_i.h"
14#include "rate.h"
15
16
17static void __check_vhtcap_disable(struct ieee80211_sub_if_data *sdata,
18 struct ieee80211_sta_vht_cap *vht_cap,
19 u32 flag)
20{
21 __le32 le_flag = cpu_to_le32(flag);
22
23 if (sdata->u.mgd.vht_capa_mask.vht_cap_info & le_flag &&
24 !(sdata->u.mgd.vht_capa.vht_cap_info & le_flag))
25 vht_cap->cap &= ~flag;
26}
27
28void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
29 struct ieee80211_sta_vht_cap *vht_cap)
30{
31 int i;
32 u16 rxmcs_mask, rxmcs_cap, rxmcs_n, txmcs_mask, txmcs_cap, txmcs_n;
33
34 if (!vht_cap->vht_supported)
35 return;
36
37 if (sdata->vif.type != NL80211_IFTYPE_STATION)
38 return;
39
40 __check_vhtcap_disable(sdata, vht_cap,
41 IEEE80211_VHT_CAP_RXLDPC);
42 __check_vhtcap_disable(sdata, vht_cap,
43 IEEE80211_VHT_CAP_SHORT_GI_80);
44 __check_vhtcap_disable(sdata, vht_cap,
45 IEEE80211_VHT_CAP_SHORT_GI_160);
46 __check_vhtcap_disable(sdata, vht_cap,
47 IEEE80211_VHT_CAP_TXSTBC);
48 __check_vhtcap_disable(sdata, vht_cap,
49 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
50 __check_vhtcap_disable(sdata, vht_cap,
51 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE);
52 __check_vhtcap_disable(sdata, vht_cap,
53 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN);
54 __check_vhtcap_disable(sdata, vht_cap,
55 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN);
56
57 /* Allow user to decrease AMPDU length exponent */
58 if (sdata->u.mgd.vht_capa_mask.vht_cap_info &
59 cpu_to_le32(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK)) {
60 u32 cap, n;
61
62 n = le32_to_cpu(sdata->u.mgd.vht_capa.vht_cap_info) &
63 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
64 n >>= IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
65 cap = vht_cap->cap & IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
66 cap >>= IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
67
68 if (n < cap) {
69 vht_cap->cap &=
70 ~IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
71 vht_cap->cap |=
72 n << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
73 }
74 }
75
76 /* Allow the user to decrease MCSes */
77 rxmcs_mask =
78 le16_to_cpu(sdata->u.mgd.vht_capa_mask.supp_mcs.rx_mcs_map);
79 rxmcs_n = le16_to_cpu(sdata->u.mgd.vht_capa.supp_mcs.rx_mcs_map);
80 rxmcs_n &= rxmcs_mask;
81 rxmcs_cap = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
82
83 txmcs_mask =
84 le16_to_cpu(sdata->u.mgd.vht_capa_mask.supp_mcs.tx_mcs_map);
85 txmcs_n = le16_to_cpu(sdata->u.mgd.vht_capa.supp_mcs.tx_mcs_map);
86 txmcs_n &= txmcs_mask;
87 txmcs_cap = le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
88 for (i = 0; i < 8; i++) {
89 u8 m, n, c;
90
91 m = (rxmcs_mask >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
92 n = (rxmcs_n >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
93 c = (rxmcs_cap >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
94
95 if (m && ((c != IEEE80211_VHT_MCS_NOT_SUPPORTED && n < c) ||
96 n == IEEE80211_VHT_MCS_NOT_SUPPORTED)) {
97 rxmcs_cap &= ~(3 << 2*i);
98 rxmcs_cap |= (rxmcs_n & (3 << 2*i));
99 }
100
101 m = (txmcs_mask >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
102 n = (txmcs_n >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
103 c = (txmcs_cap >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
104
105 if (m && ((c != IEEE80211_VHT_MCS_NOT_SUPPORTED && n < c) ||
106 n == IEEE80211_VHT_MCS_NOT_SUPPORTED)) {
107 txmcs_cap &= ~(3 << 2*i);
108 txmcs_cap |= (txmcs_n & (3 << 2*i));
109 }
110 }
111 vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_cap);
112 vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_cap);
113}
114
115void
116ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
117 struct ieee80211_supported_band *sband,
118 const struct ieee80211_sta_vht_cap *own_vht_cap,
119 const struct ieee80211_vht_cap *vht_cap_ie,
120 const struct ieee80211_vht_cap *vht_cap_ie2,
121 struct link_sta_info *link_sta)
122{
123 struct ieee80211_sta_vht_cap *vht_cap = &link_sta->pub->vht_cap;
124 struct ieee80211_sta_vht_cap own_cap;
125 u32 cap_info, i;
126 u32 mpdu_len;
127
128 memset(vht_cap, 0, sizeof(*vht_cap));
129
130 if (!link_sta->pub->ht_cap.ht_supported)
131 return;
132
133 if (!vht_cap_ie || !own_vht_cap->vht_supported)
134 return;
135
136 /* NDI station are using the capabilities from the NMI station */
137 if (WARN_ON_ONCE(sdata->vif.type == NL80211_IFTYPE_NAN_DATA))
138 return;
139
140 if (sband) {
141 /* Allow VHT if at least one channel on the sband supports 80 MHz */
142 bool have_80mhz = false;
143
144 for (i = 0; i < sband->n_channels; i++) {
145 if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
146 IEEE80211_CHAN_NO_80MHZ))
147 continue;
148
149 have_80mhz = true;
150 break;
151 }
152
153 if (!have_80mhz)
154 return;
155 }
156
157 /*
158 * A VHT STA must support 40 MHz, but if we verify that here
159 * then we break a few things - some APs (e.g. Netgear R6300v2
160 * and others based on the BCM4360 chipset) will unset this
161 * capability bit when operating in 20 MHz.
162 */
163
164 vht_cap->vht_supported = true;
165
166 own_cap = *own_vht_cap;
167 /*
168 * If user has specified capability overrides, take care
169 * of that if the station we're setting up is the AP that
170 * we advertised a restricted capability set to. Override
171 * our own capabilities and then use those below.
172 */
173 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
174 !test_sta_flag(link_sta->sta, WLAN_STA_TDLS_PEER))
175 ieee80211_apply_vhtcap_overrides(sdata, &own_cap);
176
177 /* take some capabilities as-is */
178 cap_info = le32_to_cpu(vht_cap_ie->vht_cap_info);
179 vht_cap->cap = cap_info;
180 vht_cap->cap &= IEEE80211_VHT_CAP_RXLDPC |
181 IEEE80211_VHT_CAP_VHT_TXOP_PS |
182 IEEE80211_VHT_CAP_HTC_VHT |
183 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK |
184 IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB |
185 IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB |
186 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
187 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
188
189 vht_cap->cap |= min_t(u32, cap_info & IEEE80211_VHT_CAP_MAX_MPDU_MASK,
190 own_cap.cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK);
191
192 /* and some based on our own capabilities */
193 switch (own_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
194 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
195 vht_cap->cap |= cap_info &
196 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
197 break;
198 case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
199 vht_cap->cap |= cap_info &
200 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
201 break;
202 default:
203 /* nothing */
204 break;
205 }
206
207 /* symmetric capabilities */
208 vht_cap->cap |= cap_info & own_cap.cap &
209 (IEEE80211_VHT_CAP_SHORT_GI_80 |
210 IEEE80211_VHT_CAP_SHORT_GI_160);
211
212 /* remaining ones */
213 if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
214 vht_cap->cap |= cap_info &
215 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
216 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
217
218 if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
219 vht_cap->cap |= cap_info &
220 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
221 IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
222
223 if (own_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
224 vht_cap->cap |= cap_info &
225 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
226
227 if (own_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
228 vht_cap->cap |= cap_info &
229 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
230
231 if (own_cap.cap & IEEE80211_VHT_CAP_TXSTBC)
232 vht_cap->cap |= cap_info & IEEE80211_VHT_CAP_RXSTBC_MASK;
233
234 if (own_cap.cap & IEEE80211_VHT_CAP_RXSTBC_MASK)
235 vht_cap->cap |= cap_info & IEEE80211_VHT_CAP_TXSTBC;
236
237 /* Copy peer MCS info, the driver might need them. */
238 memcpy(&vht_cap->vht_mcs, &vht_cap_ie->supp_mcs,
239 sizeof(struct ieee80211_vht_mcs_info));
240
241 /* copy EXT_NSS_BW Support value or remove the capability */
242 if (ieee80211_hw_check(&sdata->local->hw, SUPPORTS_VHT_EXT_NSS_BW))
243 vht_cap->cap |= (cap_info & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK);
244 else
245 vht_cap->vht_mcs.tx_highest &=
246 ~cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
247
248 /* but also restrict MCSes */
249 for (i = 0; i < 8; i++) {
250 u16 own_rx, own_tx, peer_rx, peer_tx;
251
252 own_rx = le16_to_cpu(own_cap.vht_mcs.rx_mcs_map);
253 own_rx = (own_rx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
254
255 own_tx = le16_to_cpu(own_cap.vht_mcs.tx_mcs_map);
256 own_tx = (own_tx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
257
258 peer_rx = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
259 peer_rx = (peer_rx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
260
261 peer_tx = le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
262 peer_tx = (peer_tx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
263
264 if (peer_tx != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
265 if (own_rx == IEEE80211_VHT_MCS_NOT_SUPPORTED)
266 peer_tx = IEEE80211_VHT_MCS_NOT_SUPPORTED;
267 else if (own_rx < peer_tx)
268 peer_tx = own_rx;
269 }
270
271 if (peer_rx != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
272 if (own_tx == IEEE80211_VHT_MCS_NOT_SUPPORTED)
273 peer_rx = IEEE80211_VHT_MCS_NOT_SUPPORTED;
274 else if (own_tx < peer_rx)
275 peer_rx = own_tx;
276 }
277
278 vht_cap->vht_mcs.rx_mcs_map &=
279 ~cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << i * 2);
280 vht_cap->vht_mcs.rx_mcs_map |= cpu_to_le16(peer_rx << i * 2);
281
282 vht_cap->vht_mcs.tx_mcs_map &=
283 ~cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << i * 2);
284 vht_cap->vht_mcs.tx_mcs_map |= cpu_to_le16(peer_tx << i * 2);
285 }
286
287 /*
288 * This is a workaround for VHT-enabled STAs which break the spec
289 * and have the VHT-MCS Rx map filled in with value 3 for all eight
290 * spatial streams, an example is AR9462.
291 *
292 * As per spec, in section 22.1.1 Introduction to the VHT PHY
293 * A VHT STA shall support at least single spatial stream VHT-MCSs
294 * 0 to 7 (transmit and receive) in all supported channel widths.
295 */
296 if (vht_cap->vht_mcs.rx_mcs_map == cpu_to_le16(0xFFFF)) {
297 vht_cap->vht_supported = false;
298 sdata_info(sdata,
299 "Ignoring VHT IE from %pM (link:%pM) due to invalid rx_mcs_map\n",
300 link_sta->sta->addr, link_sta->addr);
301 return;
302 }
303
304 /*
305 * Work around the Cisco 9115 FW 17.3 bug by taking the min of
306 * both reported MPDU lengths.
307 */
308 mpdu_len = vht_cap->cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK;
309 if (vht_cap_ie2)
310 mpdu_len = min_t(u32, mpdu_len,
311 le32_get_bits(vht_cap_ie2->vht_cap_info,
312 IEEE80211_VHT_CAP_MAX_MPDU_MASK));
313
314 /*
315 * FIXME - should the amsdu len be per link? store per link
316 * and maintain a minimum?
317 */
318 switch (mpdu_len) {
319 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454:
320 link_sta->pub->agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_11454;
321 break;
322 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991:
323 link_sta->pub->agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_7991;
324 break;
325 case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895:
326 default:
327 link_sta->pub->agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_3895;
328 break;
329 }
330
331 ieee80211_sta_recalc_aggregates(&link_sta->sta->sta);
332}
333
334u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
335 struct link_sta_info *link_sta,
336 u8 opmode, enum nl80211_band band)
337{
338 enum ieee80211_sta_rx_bandwidth new_bw;
339 struct sta_opmode_info sta_opmode = {};
340 struct ieee80211_link_data *link;
341 u32 changed = 0;
342 u8 nss;
343
344 link = sdata_dereference(sdata->link[link_sta->link_id], sdata);
345 if (WARN_ON(!link))
346 return 0;
347
348 /* ignore - no support for BF yet */
349 if (opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF)
350 return 0;
351
352 nss = opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_MASK;
353 nss >>= IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT;
354 nss += 1;
355
356 if (link_sta->op_mode_nss != nss) {
357 if (nss <= link_sta->capa_nss) {
358 link_sta->op_mode_nss = nss;
359
360 if (nss != link_sta->pub->rx_nss) {
361 link_sta->pub->rx_nss = nss;
362 changed |= IEEE80211_RC_NSS_CHANGED;
363 sta_opmode.rx_nss = link_sta->pub->rx_nss;
364 sta_opmode.changed |= STA_OPMODE_N_SS_CHANGED;
365 }
366 } else {
367 sdata_dbg(sdata,
368 "Ignore NSS change to invalid %d in VHT opmode notif from %pM",
369 nss, link_sta->pub->addr);
370 }
371 }
372
373 switch (opmode & IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK) {
374 case IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ:
375 /* ignore IEEE80211_OPMODE_NOTIF_BW_160_80P80 must not be set */
376 link_sta->op_mode_bw = IEEE80211_STA_RX_BW_20;
377 break;
378 case IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ:
379 /* ignore IEEE80211_OPMODE_NOTIF_BW_160_80P80 must not be set */
380 link_sta->op_mode_bw = IEEE80211_STA_RX_BW_40;
381 break;
382 case IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ:
383 if (opmode & IEEE80211_OPMODE_NOTIF_BW_160_80P80)
384 link_sta->op_mode_bw = IEEE80211_STA_RX_BW_160;
385 else
386 link_sta->op_mode_bw = IEEE80211_STA_RX_BW_80;
387 break;
388 case IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ:
389 /* legacy only, no longer used by newer spec */
390 link_sta->op_mode_bw = IEEE80211_STA_RX_BW_160;
391 break;
392 }
393
394 new_bw = ieee80211_sta_current_bw(link_sta, &link->conf->chanreq.oper,
395 IEEE80211_STA_BW_TX_TO_STA);
396 if (new_bw != link_sta->pub->bandwidth) {
397 link_sta->pub->bandwidth = new_bw;
398 sta_opmode.bw = ieee80211_sta_rx_bw_to_chan_width(new_bw);
399 changed |= IEEE80211_RC_BW_CHANGED;
400 sta_opmode.changed |= STA_OPMODE_MAX_BW_CHANGED;
401 }
402
403 if (sta_opmode.changed)
404 cfg80211_sta_opmode_change_notify(sdata->dev, link_sta->addr,
405 &sta_opmode, GFP_KERNEL);
406
407 return changed;
408}
409
410void ieee80211_process_mu_groups(struct ieee80211_sub_if_data *sdata,
411 struct ieee80211_link_data *link,
412 struct ieee80211_mgmt *mgmt)
413{
414 struct ieee80211_bss_conf *link_conf = link->conf;
415
416 if (!link_conf->mu_mimo_owner)
417 return;
418
419 if (!memcmp(mgmt->u.action.vht_group_notif.position,
420 link_conf->mu_group.position, WLAN_USER_POSITION_LEN) &&
421 !memcmp(mgmt->u.action.vht_group_notif.membership,
422 link_conf->mu_group.membership, WLAN_MEMBERSHIP_LEN))
423 return;
424
425 memcpy(link_conf->mu_group.membership,
426 mgmt->u.action.vht_group_notif.membership,
427 WLAN_MEMBERSHIP_LEN);
428 memcpy(link_conf->mu_group.position,
429 mgmt->u.action.vht_group_notif.position,
430 WLAN_USER_POSITION_LEN);
431
432 ieee80211_link_info_change_notify(sdata, link,
433 BSS_CHANGED_MU_GROUPS);
434}
435
436void ieee80211_update_mu_groups(struct ieee80211_vif *vif, unsigned int link_id,
437 const u8 *membership, const u8 *position)
438{
439 struct ieee80211_bss_conf *link_conf;
440
441 rcu_read_lock();
442 link_conf = rcu_dereference(vif->link_conf[link_id]);
443
444 if (!WARN_ON_ONCE(!link_conf || !link_conf->mu_mimo_owner)) {
445 memcpy(link_conf->mu_group.membership, membership,
446 WLAN_MEMBERSHIP_LEN);
447 memcpy(link_conf->mu_group.position, position,
448 WLAN_USER_POSITION_LEN);
449 }
450 rcu_read_unlock();
451}
452EXPORT_SYMBOL_GPL(ieee80211_update_mu_groups);
453
454void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
455 struct link_sta_info *link_sta,
456 u8 opmode, enum nl80211_band band)
457{
458 struct ieee80211_local *local = sdata->local;
459 struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
460
461 u32 changed = __ieee80211_vht_handle_opmode(sdata, link_sta,
462 opmode, band);
463
464 if (changed > 0) {
465 ieee80211_recalc_min_chandef(sdata, link_sta->link_id);
466 rate_control_rate_update(local, sband, link_sta, changed);
467 }
468}
469
470void ieee80211_get_vht_mask_from_cap(__le16 vht_cap,
471 u16 vht_mask[NL80211_VHT_NSS_MAX])
472{
473 int i;
474 u16 mask, cap = le16_to_cpu(vht_cap);
475
476 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
477 mask = (cap >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
478 switch (mask) {
479 case IEEE80211_VHT_MCS_SUPPORT_0_7:
480 vht_mask[i] = 0x00FF;
481 break;
482 case IEEE80211_VHT_MCS_SUPPORT_0_8:
483 vht_mask[i] = 0x01FF;
484 break;
485 case IEEE80211_VHT_MCS_SUPPORT_0_9:
486 vht_mask[i] = 0x03FF;
487 break;
488 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
489 default:
490 vht_mask[i] = 0;
491 break;
492 }
493 }
494}