Branch data Line data Source code
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 - 2019 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 : :
17 : 0 : static void __check_vhtcap_disable(struct ieee80211_sub_if_data *sdata,
18 : : struct ieee80211_sta_vht_cap *vht_cap,
19 : : u32 flag)
20 : : {
21 : 0 : __le32 le_flag = cpu_to_le32(flag);
22 : :
23 : 0 : if (sdata->u.mgd.vht_capa_mask.vht_cap_info & le_flag &&
24 [ # # # # : 0 : !(sdata->u.mgd.vht_capa.vht_cap_info & le_flag))
# # # # #
# # # # #
# # ]
25 : 0 : vht_cap->cap &= ~flag;
26 : : }
27 : :
28 : 0 : void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
29 : : struct ieee80211_sta_vht_cap *vht_cap)
30 : : {
31 : 0 : int i;
32 : 0 : u16 rxmcs_mask, rxmcs_cap, rxmcs_n, txmcs_mask, txmcs_cap, txmcs_n;
33 : :
34 [ # # ]: 0 : if (!vht_cap->vht_supported)
35 : : return;
36 : :
37 [ # # ]: 0 : if (sdata->vif.type != NL80211_IFTYPE_STATION)
38 : : return;
39 : :
40 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
41 : : IEEE80211_VHT_CAP_RXLDPC);
42 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
43 : : IEEE80211_VHT_CAP_SHORT_GI_80);
44 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
45 : : IEEE80211_VHT_CAP_SHORT_GI_160);
46 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
47 : : IEEE80211_VHT_CAP_TXSTBC);
48 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
49 : : IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
50 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
51 : : IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE);
52 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
53 : : IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN);
54 [ # # ]: 0 : __check_vhtcap_disable(sdata, vht_cap,
55 : : IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN);
56 : :
57 : : /* Allow user to decrease AMPDU length exponent */
58 [ # # ]: 0 : if (sdata->u.mgd.vht_capa_mask.vht_cap_info &
59 : : cpu_to_le32(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK)) {
60 : 0 : u32 cap, n;
61 : :
62 : 0 : n = le32_to_cpu(sdata->u.mgd.vht_capa.vht_cap_info) &
63 : : IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
64 : 0 : n >>= IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
65 : 0 : cap = vht_cap->cap & IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
66 : 0 : cap >>= IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
67 : :
68 [ # # ]: 0 : if (n < cap) {
69 : 0 : vht_cap->cap &=
70 : : ~IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
71 : 0 : vht_cap->cap |=
72 : 0 : n << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
73 : : }
74 : : }
75 : :
76 : : /* Allow the user to decrease MCSes */
77 : 0 : rxmcs_mask =
78 : : le16_to_cpu(sdata->u.mgd.vht_capa_mask.supp_mcs.rx_mcs_map);
79 : 0 : rxmcs_n = le16_to_cpu(sdata->u.mgd.vht_capa.supp_mcs.rx_mcs_map);
80 : 0 : rxmcs_n &= rxmcs_mask;
81 : 0 : rxmcs_cap = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
82 : :
83 : 0 : txmcs_mask =
84 : : le16_to_cpu(sdata->u.mgd.vht_capa_mask.supp_mcs.tx_mcs_map);
85 : 0 : txmcs_n = le16_to_cpu(sdata->u.mgd.vht_capa.supp_mcs.tx_mcs_map);
86 : 0 : txmcs_n &= txmcs_mask;
87 : 0 : txmcs_cap = le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
88 [ # # ]: 0 : for (i = 0; i < 8; i++) {
89 : 0 : u8 m, n, c;
90 : :
91 : 0 : m = (rxmcs_mask >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
92 : 0 : n = (rxmcs_n >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
93 : 0 : c = (rxmcs_cap >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
94 : :
95 [ # # # # : 0 : if (m && ((c != IEEE80211_VHT_MCS_NOT_SUPPORTED && n < c) ||
# # ]
96 : : n == IEEE80211_VHT_MCS_NOT_SUPPORTED)) {
97 : 0 : rxmcs_cap &= ~(3 << 2*i);
98 : 0 : rxmcs_cap |= (rxmcs_n & (3 << 2*i));
99 : : }
100 : :
101 : 0 : m = (txmcs_mask >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
102 : 0 : n = (txmcs_n >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
103 : 0 : c = (txmcs_cap >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
104 : :
105 [ # # # # : 0 : if (m && ((c != IEEE80211_VHT_MCS_NOT_SUPPORTED && n < c) ||
# # ]
106 : : n == IEEE80211_VHT_MCS_NOT_SUPPORTED)) {
107 : 0 : txmcs_cap &= ~(3 << 2*i);
108 : 0 : txmcs_cap |= (txmcs_n & (3 << 2*i));
109 : : }
110 : : }
111 : 0 : vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_cap);
112 : 0 : vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_cap);
113 : : }
114 : :
115 : : void
116 : 0 : ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
117 : : struct ieee80211_supported_band *sband,
118 : : const struct ieee80211_vht_cap *vht_cap_ie,
119 : : struct sta_info *sta)
120 : : {
121 : 0 : struct ieee80211_sta_vht_cap *vht_cap = &sta->sta.vht_cap;
122 : 0 : struct ieee80211_sta_vht_cap own_cap;
123 : 0 : u32 cap_info, i;
124 : 0 : bool have_80mhz;
125 : :
126 : 0 : memset(vht_cap, 0, sizeof(*vht_cap));
127 : :
128 [ # # ]: 0 : if (!sta->sta.ht_cap.ht_supported)
129 : 0 : return;
130 : :
131 [ # # # # ]: 0 : if (!vht_cap_ie || !sband->vht_cap.vht_supported)
132 : : return;
133 : :
134 : : /* Allow VHT if at least one channel on the sband supports 80 MHz */
135 : : have_80mhz = false;
136 [ # # ]: 0 : for (i = 0; i < sband->n_channels; i++) {
137 [ # # ]: 0 : if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
138 : : IEEE80211_CHAN_NO_80MHZ))
139 : 0 : continue;
140 : :
141 : : have_80mhz = true;
142 : : break;
143 : : }
144 : :
145 [ # # ]: 0 : if (!have_80mhz)
146 : : return;
147 : :
148 : : /*
149 : : * A VHT STA must support 40 MHz, but if we verify that here
150 : : * then we break a few things - some APs (e.g. Netgear R6300v2
151 : : * and others based on the BCM4360 chipset) will unset this
152 : : * capability bit when operating in 20 MHz.
153 : : */
154 : :
155 : 0 : vht_cap->vht_supported = true;
156 : :
157 : 0 : own_cap = sband->vht_cap;
158 : : /*
159 : : * If user has specified capability overrides, take care
160 : : * of that if the station we're setting up is the AP that
161 : : * we advertised a restricted capability set to. Override
162 : : * our own capabilities and then use those below.
163 : : */
164 [ # # # # ]: 0 : if (sdata->vif.type == NL80211_IFTYPE_STATION &&
165 : : !test_sta_flag(sta, WLAN_STA_TDLS_PEER))
166 : 0 : ieee80211_apply_vhtcap_overrides(sdata, &own_cap);
167 : :
168 : : /* take some capabilities as-is */
169 : 0 : cap_info = le32_to_cpu(vht_cap_ie->vht_cap_info);
170 : 0 : vht_cap->cap = cap_info;
171 : 0 : vht_cap->cap &= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895 |
172 : : IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991 |
173 : : IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
174 : : IEEE80211_VHT_CAP_RXLDPC |
175 : : IEEE80211_VHT_CAP_VHT_TXOP_PS |
176 : : IEEE80211_VHT_CAP_HTC_VHT |
177 : : IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK |
178 : : IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB |
179 : : IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB |
180 : : IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
181 : : IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
182 : :
183 : : /* and some based on our own capabilities */
184 [ # # # ]: 0 : switch (own_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
185 : 0 : case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
186 : 0 : vht_cap->cap |= cap_info &
187 : : IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
188 : 0 : break;
189 : 0 : case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
190 : 0 : vht_cap->cap |= cap_info &
191 : : IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
192 : 0 : break;
193 : : default:
194 : : /* nothing */
195 : : break;
196 : : }
197 : :
198 : : /* symmetric capabilities */
199 : 0 : vht_cap->cap |= cap_info & own_cap.cap &
200 : : (IEEE80211_VHT_CAP_SHORT_GI_80 |
201 : : IEEE80211_VHT_CAP_SHORT_GI_160);
202 : :
203 : : /* remaining ones */
204 [ # # ]: 0 : if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
205 : 0 : vht_cap->cap |= cap_info &
206 : : (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
207 : : IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
208 : :
209 [ # # ]: 0 : if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
210 : 0 : vht_cap->cap |= cap_info &
211 : : (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
212 : : IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
213 : :
214 [ # # ]: 0 : if (own_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
215 : 0 : vht_cap->cap |= cap_info &
216 : : IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
217 : :
218 [ # # ]: 0 : if (own_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
219 : 0 : vht_cap->cap |= cap_info &
220 : : IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
221 : :
222 [ # # ]: 0 : if (own_cap.cap & IEEE80211_VHT_CAP_TXSTBC)
223 : 0 : vht_cap->cap |= cap_info & IEEE80211_VHT_CAP_RXSTBC_MASK;
224 : :
225 [ # # ]: 0 : if (own_cap.cap & IEEE80211_VHT_CAP_RXSTBC_MASK)
226 : 0 : vht_cap->cap |= cap_info & IEEE80211_VHT_CAP_TXSTBC;
227 : :
228 : : /* Copy peer MCS info, the driver might need them. */
229 : 0 : memcpy(&vht_cap->vht_mcs, &vht_cap_ie->supp_mcs,
230 : : sizeof(struct ieee80211_vht_mcs_info));
231 : :
232 : : /* copy EXT_NSS_BW Support value or remove the capability */
233 [ # # ]: 0 : if (ieee80211_hw_check(&sdata->local->hw, SUPPORTS_VHT_EXT_NSS_BW))
234 : 0 : vht_cap->cap |= (cap_info & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK);
235 : : else
236 : 0 : vht_cap->vht_mcs.tx_highest &=
237 : : ~cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE);
238 : :
239 : : /* but also restrict MCSes */
240 [ # # ]: 0 : for (i = 0; i < 8; i++) {
241 : 0 : u16 own_rx, own_tx, peer_rx, peer_tx;
242 : :
243 : 0 : own_rx = le16_to_cpu(own_cap.vht_mcs.rx_mcs_map);
244 : 0 : own_rx = (own_rx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
245 : :
246 : 0 : own_tx = le16_to_cpu(own_cap.vht_mcs.tx_mcs_map);
247 : 0 : own_tx = (own_tx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
248 : :
249 : 0 : peer_rx = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
250 : 0 : peer_rx = (peer_rx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
251 : :
252 : 0 : peer_tx = le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
253 : 0 : peer_tx = (peer_tx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
254 : :
255 [ # # ]: 0 : if (peer_tx != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
256 [ # # ]: 0 : if (own_rx == IEEE80211_VHT_MCS_NOT_SUPPORTED)
257 : : peer_tx = IEEE80211_VHT_MCS_NOT_SUPPORTED;
258 : 0 : else if (own_rx < peer_tx)
259 : : peer_tx = own_rx;
260 : : }
261 : :
262 [ # # ]: 0 : if (peer_rx != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
263 [ # # ]: 0 : if (own_tx == IEEE80211_VHT_MCS_NOT_SUPPORTED)
264 : : peer_rx = IEEE80211_VHT_MCS_NOT_SUPPORTED;
265 : 0 : else if (own_tx < peer_rx)
266 : : peer_rx = own_tx;
267 : : }
268 : :
269 : 0 : vht_cap->vht_mcs.rx_mcs_map &=
270 : 0 : ~cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << i * 2);
271 : 0 : vht_cap->vht_mcs.rx_mcs_map |= cpu_to_le16(peer_rx << i * 2);
272 : :
273 : 0 : vht_cap->vht_mcs.tx_mcs_map &=
274 : : ~cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << i * 2);
275 : 0 : vht_cap->vht_mcs.tx_mcs_map |= cpu_to_le16(peer_tx << i * 2);
276 : : }
277 : :
278 : : /*
279 : : * This is a workaround for VHT-enabled STAs which break the spec
280 : : * and have the VHT-MCS Rx map filled in with value 3 for all eight
281 : : * spacial streams, an example is AR9462.
282 : : *
283 : : * As per spec, in section 22.1.1 Introduction to the VHT PHY
284 : : * A VHT STA shall support at least single spactial stream VHT-MCSs
285 : : * 0 to 7 (transmit and receive) in all supported channel widths.
286 : : */
287 [ # # ]: 0 : if (vht_cap->vht_mcs.rx_mcs_map == cpu_to_le16(0xFFFF)) {
288 : 0 : vht_cap->vht_supported = false;
289 : 0 : sdata_info(sdata, "Ignoring VHT IE from %pM due to invalid rx_mcs_map\n",
290 : : sta->addr);
291 : 0 : return;
292 : : }
293 : :
294 : : /* finally set up the bandwidth */
295 [ # # ]: 0 : switch (vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
296 : 0 : case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
297 : : case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
298 : 0 : sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_160;
299 : 0 : break;
300 : 0 : default:
301 : 0 : sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_80;
302 : :
303 [ # # ]: 0 : if (!(vht_cap->vht_mcs.tx_highest &
304 : : cpu_to_le16(IEEE80211_VHT_EXT_NSS_BW_CAPABLE)))
305 : : break;
306 : :
307 : : /*
308 : : * If this is non-zero, then it does support 160 MHz after all,
309 : : * in one form or the other. We don't distinguish here (or even
310 : : * above) between 160 and 80+80 yet.
311 : : */
312 [ # # ]: 0 : if (cap_info & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK)
313 : 0 : sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_160;
314 : : }
315 : :
316 : 0 : sta->sta.bandwidth = ieee80211_sta_cur_vht_bw(sta);
317 : :
318 : : /* If HT IE reported 3839 bytes only, stay with that size. */
319 [ # # ]: 0 : if (sta->sta.max_amsdu_len == IEEE80211_MAX_MPDU_LEN_HT_3839)
320 : : return;
321 : :
322 [ # # # ]: 0 : switch (vht_cap->cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK) {
323 : 0 : case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454:
324 : 0 : sta->sta.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_11454;
325 : 0 : break;
326 : 0 : case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991:
327 : 0 : sta->sta.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_7991;
328 : 0 : break;
329 : 0 : case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895:
330 : : default:
331 : 0 : sta->sta.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_VHT_3895;
332 : 0 : break;
333 : : }
334 : : }
335 : :
336 : 0 : enum ieee80211_sta_rx_bandwidth ieee80211_sta_cap_rx_bw(struct sta_info *sta)
337 : : {
338 : 0 : struct ieee80211_sta_vht_cap *vht_cap = &sta->sta.vht_cap;
339 : 0 : u32 cap_width;
340 : :
341 [ # # ]: 0 : if (!vht_cap->vht_supported)
342 : 0 : return sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
343 : 0 : IEEE80211_STA_RX_BW_40 :
344 : : IEEE80211_STA_RX_BW_20;
345 : :
346 : 0 : cap_width = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
347 : :
348 : 0 : if (cap_width == IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ ||
349 [ # # # # ]: 0 : cap_width == IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
350 : : return IEEE80211_STA_RX_BW_160;
351 : :
352 : : /*
353 : : * If this is non-zero, then it does support 160 MHz after all,
354 : : * in one form or the other. We don't distinguish here (or even
355 : : * above) between 160 and 80+80 yet.
356 : : */
357 [ # # # # ]: 0 : if (vht_cap->cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK)
358 : 0 : return IEEE80211_STA_RX_BW_160;
359 : :
360 : : return IEEE80211_STA_RX_BW_80;
361 : : }
362 : :
363 : 0 : enum nl80211_chan_width ieee80211_sta_cap_chan_bw(struct sta_info *sta)
364 : : {
365 : 0 : struct ieee80211_sta_vht_cap *vht_cap = &sta->sta.vht_cap;
366 : 0 : u32 cap_width;
367 : :
368 [ # # ]: 0 : if (!vht_cap->vht_supported) {
369 [ # # ]: 0 : if (!sta->sta.ht_cap.ht_supported)
370 : : return NL80211_CHAN_WIDTH_20_NOHT;
371 : :
372 : 0 : return sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
373 [ # # ]: 0 : NL80211_CHAN_WIDTH_40 : NL80211_CHAN_WIDTH_20;
374 : : }
375 : :
376 : 0 : cap_width = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
377 : :
378 [ # # ]: 0 : if (cap_width == IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ)
379 : : return NL80211_CHAN_WIDTH_160;
380 [ # # ]: 0 : else if (cap_width == IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
381 : 0 : return NL80211_CHAN_WIDTH_80P80;
382 : :
383 : : return NL80211_CHAN_WIDTH_80;
384 : : }
385 : :
386 : : enum nl80211_chan_width
387 : 0 : ieee80211_sta_rx_bw_to_chan_width(struct sta_info *sta)
388 : : {
389 : 0 : enum ieee80211_sta_rx_bandwidth cur_bw = sta->sta.bandwidth;
390 : 0 : struct ieee80211_sta_vht_cap *vht_cap = &sta->sta.vht_cap;
391 : 0 : u32 cap_width;
392 : :
393 [ # # # # : 0 : switch (cur_bw) {
# ]
394 : 0 : case IEEE80211_STA_RX_BW_20:
395 [ # # # # ]: 0 : if (!sta->sta.ht_cap.ht_supported)
396 : : return NL80211_CHAN_WIDTH_20_NOHT;
397 : : else
398 : 0 : return NL80211_CHAN_WIDTH_20;
399 : : case IEEE80211_STA_RX_BW_40:
400 : : return NL80211_CHAN_WIDTH_40;
401 : 0 : case IEEE80211_STA_RX_BW_80:
402 : 0 : return NL80211_CHAN_WIDTH_80;
403 : 0 : case IEEE80211_STA_RX_BW_160:
404 : 0 : cap_width =
405 : 0 : vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
406 : :
407 [ # # # # ]: 0 : if (cap_width == IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ)
408 : 0 : return NL80211_CHAN_WIDTH_160;
409 : :
410 : : return NL80211_CHAN_WIDTH_80P80;
411 : 0 : default:
412 : 0 : return NL80211_CHAN_WIDTH_20;
413 : : }
414 : : }
415 : :
416 : : enum ieee80211_sta_rx_bandwidth
417 : 0 : ieee80211_chan_width_to_rx_bw(enum nl80211_chan_width width)
418 : : {
419 [ # # ]: 0 : switch (width) {
420 : : case NL80211_CHAN_WIDTH_20_NOHT:
421 : : case NL80211_CHAN_WIDTH_20:
422 : : return IEEE80211_STA_RX_BW_20;
423 : : case NL80211_CHAN_WIDTH_40:
424 : : return IEEE80211_STA_RX_BW_40;
425 : : case NL80211_CHAN_WIDTH_80:
426 : : return IEEE80211_STA_RX_BW_80;
427 : : case NL80211_CHAN_WIDTH_160:
428 : : case NL80211_CHAN_WIDTH_80P80:
429 : : return IEEE80211_STA_RX_BW_160;
430 : : default:
431 : 0 : WARN_ON_ONCE(1);
432 : 0 : return IEEE80211_STA_RX_BW_20;
433 : : }
434 : : }
435 : :
436 : 0 : enum ieee80211_sta_rx_bandwidth ieee80211_sta_cur_vht_bw(struct sta_info *sta)
437 : : {
438 : 0 : struct ieee80211_sub_if_data *sdata = sta->sdata;
439 : 0 : enum ieee80211_sta_rx_bandwidth bw;
440 : 0 : enum nl80211_chan_width bss_width = sdata->vif.bss_conf.chandef.width;
441 : :
442 [ # # ]: 0 : bw = ieee80211_sta_cap_rx_bw(sta);
443 : 0 : bw = min(bw, sta->cur_max_bandwidth);
444 : :
445 : : /* Don't consider AP's bandwidth for TDLS peers, section 11.23.1 of
446 : : * IEEE80211-2016 specification makes higher bandwidth operation
447 : : * possible on the TDLS link if the peers have wider bandwidth
448 : : * capability.
449 : : */
450 [ # # # # ]: 0 : if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
451 : : test_sta_flag(sta, WLAN_STA_TDLS_WIDER_BW))
452 : : return bw;
453 : :
454 [ # # ]: 0 : bw = min(bw, ieee80211_chan_width_to_rx_bw(bss_width));
455 : :
456 : 0 : return bw;
457 : : }
458 : :
459 : 0 : void ieee80211_sta_set_rx_nss(struct sta_info *sta)
460 : : {
461 : 0 : u8 ht_rx_nss = 0, vht_rx_nss = 0;
462 : :
463 : : /* if we received a notification already don't overwrite it */
464 [ # # ]: 0 : if (sta->sta.rx_nss)
465 : : return;
466 : :
467 [ # # ]: 0 : if (sta->sta.ht_cap.ht_supported) {
468 [ # # ]: 0 : if (sta->sta.ht_cap.mcs.rx_mask[0])
469 : 0 : ht_rx_nss++;
470 [ # # ]: 0 : if (sta->sta.ht_cap.mcs.rx_mask[1])
471 : 0 : ht_rx_nss++;
472 [ # # ]: 0 : if (sta->sta.ht_cap.mcs.rx_mask[2])
473 : 0 : ht_rx_nss++;
474 [ # # ]: 0 : if (sta->sta.ht_cap.mcs.rx_mask[3])
475 : 0 : ht_rx_nss++;
476 : : /* FIXME: consider rx_highest? */
477 : : }
478 : :
479 [ # # ]: 0 : if (sta->sta.vht_cap.vht_supported) {
480 : 0 : int i;
481 : 0 : u16 rx_mcs_map;
482 : :
483 : 0 : rx_mcs_map = le16_to_cpu(sta->sta.vht_cap.vht_mcs.rx_mcs_map);
484 : :
485 [ # # ]: 0 : for (i = 7; i >= 0; i--) {
486 : 0 : u8 mcs = (rx_mcs_map >> (2 * i)) & 3;
487 : :
488 [ # # ]: 0 : if (mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
489 : 0 : vht_rx_nss = i + 1;
490 : 0 : break;
491 : : }
492 : : }
493 : : /* FIXME: consider rx_highest? */
494 : : }
495 : :
496 : 0 : ht_rx_nss = max(ht_rx_nss, vht_rx_nss);
497 : 0 : sta->sta.rx_nss = max_t(u8, 1, ht_rx_nss);
498 : : }
499 : :
500 : 0 : u32 __ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
501 : : struct sta_info *sta, u8 opmode,
502 : : enum nl80211_band band)
503 : : {
504 : 0 : enum ieee80211_sta_rx_bandwidth new_bw;
505 : 0 : struct sta_opmode_info sta_opmode = {};
506 : 0 : u32 changed = 0;
507 : 0 : u8 nss;
508 : :
509 : : /* ignore - no support for BF yet */
510 [ # # ]: 0 : if (opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF)
511 : : return 0;
512 : :
513 : 0 : nss = opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_MASK;
514 : 0 : nss >>= IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT;
515 : 0 : nss += 1;
516 : :
517 [ # # ]: 0 : if (sta->sta.rx_nss != nss) {
518 : 0 : sta->sta.rx_nss = nss;
519 : 0 : sta_opmode.rx_nss = nss;
520 : 0 : changed |= IEEE80211_RC_NSS_CHANGED;
521 : 0 : sta_opmode.changed |= STA_OPMODE_N_SS_CHANGED;
522 : : }
523 : :
524 [ # # # # ]: 0 : switch (opmode & IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK) {
525 : 0 : case IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ:
526 : 0 : sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_20;
527 : 0 : break;
528 : 0 : case IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ:
529 : 0 : sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_40;
530 : 0 : break;
531 : 0 : case IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ:
532 : 0 : sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_80;
533 : 0 : break;
534 : 0 : case IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ:
535 : 0 : sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_160;
536 : 0 : break;
537 : : }
538 : :
539 : 0 : new_bw = ieee80211_sta_cur_vht_bw(sta);
540 [ # # ]: 0 : if (new_bw != sta->sta.bandwidth) {
541 : 0 : sta->sta.bandwidth = new_bw;
542 [ # # # # : 0 : sta_opmode.bw = ieee80211_sta_rx_bw_to_chan_width(sta);
# ]
543 : 0 : changed |= IEEE80211_RC_BW_CHANGED;
544 : 0 : sta_opmode.changed |= STA_OPMODE_MAX_BW_CHANGED;
545 : : }
546 : :
547 [ # # ]: 0 : if (sta_opmode.changed)
548 : 0 : cfg80211_sta_opmode_change_notify(sdata->dev, sta->addr,
549 : : &sta_opmode, GFP_KERNEL);
550 : :
551 : : return changed;
552 : : }
553 : :
554 : 0 : void ieee80211_process_mu_groups(struct ieee80211_sub_if_data *sdata,
555 : : struct ieee80211_mgmt *mgmt)
556 : : {
557 : 0 : struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
558 : :
559 [ # # ]: 0 : if (!sdata->vif.mu_mimo_owner)
560 : : return;
561 : :
562 : 0 : if (!memcmp(mgmt->u.action.u.vht_group_notif.position,
563 [ # # ]: 0 : bss_conf->mu_group.position, WLAN_USER_POSITION_LEN) &&
564 : 0 : !memcmp(mgmt->u.action.u.vht_group_notif.membership,
565 [ # # ]: 0 : bss_conf->mu_group.membership, WLAN_MEMBERSHIP_LEN))
566 : : return;
567 : :
568 : 0 : memcpy(bss_conf->mu_group.membership,
569 : : mgmt->u.action.u.vht_group_notif.membership,
570 : : WLAN_MEMBERSHIP_LEN);
571 : 0 : memcpy(bss_conf->mu_group.position,
572 : : mgmt->u.action.u.vht_group_notif.position,
573 : : WLAN_USER_POSITION_LEN);
574 : :
575 : 0 : ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_MU_GROUPS);
576 : : }
577 : :
578 : 0 : void ieee80211_update_mu_groups(struct ieee80211_vif *vif,
579 : : const u8 *membership, const u8 *position)
580 : : {
581 : 0 : struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
582 : :
583 [ # # # # ]: 0 : if (WARN_ON_ONCE(!vif->mu_mimo_owner))
584 : : return;
585 : :
586 : 0 : memcpy(bss_conf->mu_group.membership, membership, WLAN_MEMBERSHIP_LEN);
587 : 0 : memcpy(bss_conf->mu_group.position, position, WLAN_USER_POSITION_LEN);
588 : : }
589 : : EXPORT_SYMBOL_GPL(ieee80211_update_mu_groups);
590 : :
591 : 0 : void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
592 : : struct sta_info *sta, u8 opmode,
593 : : enum nl80211_band band)
594 : : {
595 : 0 : struct ieee80211_local *local = sdata->local;
596 : 0 : struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
597 : :
598 : 0 : u32 changed = __ieee80211_vht_handle_opmode(sdata, sta, opmode, band);
599 : :
600 [ # # ]: 0 : if (changed > 0) {
601 : 0 : ieee80211_recalc_min_chandef(sdata);
602 : 0 : rate_control_rate_update(local, sband, sta, changed);
603 : : }
604 : 0 : }
605 : :
606 : 0 : void ieee80211_get_vht_mask_from_cap(__le16 vht_cap,
607 : : u16 vht_mask[NL80211_VHT_NSS_MAX])
608 : : {
609 : 0 : int i;
610 : 0 : u16 mask, cap = le16_to_cpu(vht_cap);
611 : :
612 [ # # ]: 0 : for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
613 : 0 : mask = (cap >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
614 [ # # # # ]: 0 : switch (mask) {
615 : 0 : case IEEE80211_VHT_MCS_SUPPORT_0_7:
616 : 0 : vht_mask[i] = 0x00FF;
617 : 0 : break;
618 : 0 : case IEEE80211_VHT_MCS_SUPPORT_0_8:
619 : 0 : vht_mask[i] = 0x01FF;
620 : 0 : break;
621 : 0 : case IEEE80211_VHT_MCS_SUPPORT_0_9:
622 : 0 : vht_mask[i] = 0x03FF;
623 : 0 : break;
624 : 0 : case IEEE80211_VHT_MCS_NOT_SUPPORTED:
625 : : default:
626 : 0 : vht_mask[i] = 0;
627 : 0 : break;
628 : : }
629 : : }
630 : 0 : }
|
