ARM: tegra: dvfs: Add interface to set fmax at vmin
[linux-3.10.git] / net / mac80211 / vht.c
1 /*
2  * VHT handling
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  */
8
9 #include <linux/ieee80211.h>
10 #include <linux/export.h>
11 #include <net/mac80211.h>
12 #include "ieee80211_i.h"
13 #include "rate.h"
14
15
16 static void __check_vhtcap_disable(struct ieee80211_sub_if_data *sdata,
17                                    struct ieee80211_sta_vht_cap *vht_cap,
18                                    u32 flag)
19 {
20         __le32 le_flag = cpu_to_le32(flag);
21
22         if (sdata->u.mgd.vht_capa_mask.vht_cap_info & le_flag &&
23             !(sdata->u.mgd.vht_capa.vht_cap_info & le_flag))
24                 vht_cap->cap &= ~flag;
25 }
26
27 void ieee80211_apply_vhtcap_overrides(struct ieee80211_sub_if_data *sdata,
28                                       struct ieee80211_sta_vht_cap *vht_cap)
29 {
30         int i;
31         u16 rxmcs_mask, rxmcs_cap, rxmcs_n, txmcs_mask, txmcs_cap, txmcs_n;
32
33         if (!vht_cap->vht_supported)
34                 return;
35
36         if (sdata->vif.type != NL80211_IFTYPE_STATION)
37                 return;
38
39         __check_vhtcap_disable(sdata, vht_cap,
40                                IEEE80211_VHT_CAP_RXLDPC);
41         __check_vhtcap_disable(sdata, vht_cap,
42                                IEEE80211_VHT_CAP_SHORT_GI_80);
43         __check_vhtcap_disable(sdata, vht_cap,
44                                IEEE80211_VHT_CAP_SHORT_GI_160);
45         __check_vhtcap_disable(sdata, vht_cap,
46                                IEEE80211_VHT_CAP_TXSTBC);
47         __check_vhtcap_disable(sdata, vht_cap,
48                                IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
49         __check_vhtcap_disable(sdata, vht_cap,
50                                IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE);
51         __check_vhtcap_disable(sdata, vht_cap,
52                                IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN);
53         __check_vhtcap_disable(sdata, vht_cap,
54                                IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN);
55
56         /* Allow user to decrease AMPDU length exponent */
57         if (sdata->u.mgd.vht_capa_mask.vht_cap_info &
58             cpu_to_le32(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK)) {
59                 u32 cap, n;
60
61                 n = le32_to_cpu(sdata->u.mgd.vht_capa.vht_cap_info) &
62                         IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
63                 n >>= IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
64                 cap = vht_cap->cap & IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
65                 cap >>= IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
66
67                 if (n < cap) {
68                         vht_cap->cap &=
69                                 ~IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
70                         vht_cap->cap |=
71                                 n << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
72                 }
73         }
74
75         /* Allow the user to decrease MCSes */
76         rxmcs_mask =
77                 le16_to_cpu(sdata->u.mgd.vht_capa_mask.supp_mcs.rx_mcs_map);
78         rxmcs_n = le16_to_cpu(sdata->u.mgd.vht_capa.supp_mcs.rx_mcs_map);
79         rxmcs_n &= rxmcs_mask;
80         rxmcs_cap = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
81
82         txmcs_mask =
83                 le16_to_cpu(sdata->u.mgd.vht_capa_mask.supp_mcs.tx_mcs_map);
84         txmcs_n = le16_to_cpu(sdata->u.mgd.vht_capa.supp_mcs.tx_mcs_map);
85         txmcs_n &= txmcs_mask;
86         txmcs_cap = le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
87         for (i = 0; i < 8; i++) {
88                 u8 m, n, c;
89
90                 m = (rxmcs_mask >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
91                 n = (rxmcs_n >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
92                 c = (rxmcs_cap >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
93
94                 if (m && ((c != IEEE80211_VHT_MCS_NOT_SUPPORTED && n < c) ||
95                           n == IEEE80211_VHT_MCS_NOT_SUPPORTED)) {
96                         rxmcs_cap &= ~(3 << 2*i);
97                         rxmcs_cap |= (rxmcs_n & (3 << 2*i));
98                 }
99
100                 m = (txmcs_mask >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
101                 n = (txmcs_n >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
102                 c = (txmcs_cap >> 2*i) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
103
104                 if (m && ((c != IEEE80211_VHT_MCS_NOT_SUPPORTED && n < c) ||
105                           n == IEEE80211_VHT_MCS_NOT_SUPPORTED)) {
106                         txmcs_cap &= ~(3 << 2*i);
107                         txmcs_cap |= (txmcs_n & (3 << 2*i));
108                 }
109         }
110         vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(rxmcs_cap);
111         vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(txmcs_cap);
112 }
113
114 void
115 ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
116                                     struct ieee80211_supported_band *sband,
117                                     const struct ieee80211_vht_cap *vht_cap_ie,
118                                     struct sta_info *sta)
119 {
120         struct ieee80211_sta_vht_cap *vht_cap = &sta->sta.vht_cap;
121         struct ieee80211_sta_vht_cap own_cap;
122         u32 cap_info, i;
123
124         memset(vht_cap, 0, sizeof(*vht_cap));
125
126         if (!sta->sta.ht_cap.ht_supported)
127                 return;
128
129         if (!vht_cap_ie || !sband->vht_cap.vht_supported)
130                 return;
131
132         /* A VHT STA must support 40 MHz */
133         if (!(sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40))
134                 return;
135
136         vht_cap->vht_supported = true;
137
138         own_cap = sband->vht_cap;
139         /*
140          * If user has specified capability overrides, take care
141          * of that if the station we're setting up is the AP that
142          * we advertised a restricted capability set to. Override
143          * our own capabilities and then use those below.
144          */
145         if (sdata->vif.type == NL80211_IFTYPE_STATION &&
146             !test_sta_flag(sta, WLAN_STA_TDLS_PEER))
147                 ieee80211_apply_vhtcap_overrides(sdata, &own_cap);
148
149         /* take some capabilities as-is */
150         cap_info = le32_to_cpu(vht_cap_ie->vht_cap_info);
151         vht_cap->cap = cap_info;
152         vht_cap->cap &= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895 |
153                         IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991 |
154                         IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
155                         IEEE80211_VHT_CAP_RXLDPC |
156                         IEEE80211_VHT_CAP_VHT_TXOP_PS |
157                         IEEE80211_VHT_CAP_HTC_VHT |
158                         IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK |
159                         IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB |
160                         IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB |
161                         IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
162                         IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
163
164         /* and some based on our own capabilities */
165         switch (own_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
166         case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
167                 vht_cap->cap |= cap_info &
168                                 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
169                 break;
170         case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
171                 vht_cap->cap |= cap_info &
172                                 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
173                 break;
174         default:
175                 /* nothing */
176                 break;
177         }
178
179         /* symmetric capabilities */
180         vht_cap->cap |= cap_info & own_cap.cap &
181                         (IEEE80211_VHT_CAP_SHORT_GI_80 |
182                          IEEE80211_VHT_CAP_SHORT_GI_160);
183
184         /* remaining ones */
185         if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
186                 vht_cap->cap |= cap_info &
187                                 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
188                                  IEEE80211_VHT_CAP_BEAMFORMER_ANTENNAS_MAX |
189                                  IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MAX);
190         }
191
192         if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
193                 vht_cap->cap |= cap_info &
194                                 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE;
195
196         if (own_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
197                 vht_cap->cap |= cap_info &
198                                 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
199
200         if (own_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
201                 vht_cap->cap |= cap_info &
202                                 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
203
204         if (own_cap.cap & IEEE80211_VHT_CAP_TXSTBC)
205                 vht_cap->cap |= cap_info & IEEE80211_VHT_CAP_RXSTBC_MASK;
206
207         if (own_cap.cap & IEEE80211_VHT_CAP_RXSTBC_MASK)
208                 vht_cap->cap |= cap_info & IEEE80211_VHT_CAP_TXSTBC;
209
210         /* Copy peer MCS info, the driver might need them. */
211         memcpy(&vht_cap->vht_mcs, &vht_cap_ie->supp_mcs,
212                sizeof(struct ieee80211_vht_mcs_info));
213
214         /* but also restrict MCSes */
215         for (i = 0; i < 8; i++) {
216                 u16 own_rx, own_tx, peer_rx, peer_tx;
217
218                 own_rx = le16_to_cpu(own_cap.vht_mcs.rx_mcs_map);
219                 own_rx = (own_rx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
220
221                 own_tx = le16_to_cpu(own_cap.vht_mcs.tx_mcs_map);
222                 own_tx = (own_tx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
223
224                 peer_rx = le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
225                 peer_rx = (peer_rx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
226
227                 peer_tx = le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
228                 peer_tx = (peer_tx >> i * 2) & IEEE80211_VHT_MCS_NOT_SUPPORTED;
229
230                 if (peer_tx != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
231                         if (own_rx == IEEE80211_VHT_MCS_NOT_SUPPORTED)
232                                 peer_tx = IEEE80211_VHT_MCS_NOT_SUPPORTED;
233                         else if (own_rx < peer_tx)
234                                 peer_tx = own_rx;
235                 }
236
237                 if (peer_rx != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
238                         if (own_tx == IEEE80211_VHT_MCS_NOT_SUPPORTED)
239                                 peer_rx = IEEE80211_VHT_MCS_NOT_SUPPORTED;
240                         else if (own_tx < peer_rx)
241                                 peer_rx = own_tx;
242                 }
243
244                 vht_cap->vht_mcs.rx_mcs_map &=
245                         ~cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << i * 2);
246                 vht_cap->vht_mcs.rx_mcs_map |= cpu_to_le16(peer_rx << i * 2);
247
248                 vht_cap->vht_mcs.tx_mcs_map &=
249                         ~cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << i * 2);
250                 vht_cap->vht_mcs.tx_mcs_map |= cpu_to_le16(peer_tx << i * 2);
251         }
252
253         /* finally set up the bandwidth */
254         switch (vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
255         case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
256         case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
257                 sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_160;
258                 break;
259         default:
260                 sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_80;
261         }
262
263         sta->sta.bandwidth = ieee80211_sta_cur_vht_bw(sta);
264 }
265
266 enum ieee80211_sta_rx_bandwidth ieee80211_sta_cur_vht_bw(struct sta_info *sta)
267 {
268         struct ieee80211_sub_if_data *sdata = sta->sdata;
269         u32 cap = sta->sta.vht_cap.cap;
270         enum ieee80211_sta_rx_bandwidth bw;
271
272         if (!sta->sta.vht_cap.vht_supported) {
273                 bw = sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
274                                 IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20;
275                 goto check_max;
276         }
277
278         switch (sdata->vif.bss_conf.chandef.width) {
279         default:
280                 WARN_ON_ONCE(1);
281                 /* fall through */
282         case NL80211_CHAN_WIDTH_20_NOHT:
283         case NL80211_CHAN_WIDTH_20:
284         case NL80211_CHAN_WIDTH_40:
285                 bw = sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
286                                 IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20;
287                 break;
288         case NL80211_CHAN_WIDTH_160:
289                 if ((cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) ==
290                                 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ) {
291                         bw = IEEE80211_STA_RX_BW_160;
292                         break;
293                 }
294                 /* fall through */
295         case NL80211_CHAN_WIDTH_80P80:
296                 if ((cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) ==
297                                 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) {
298                         bw = IEEE80211_STA_RX_BW_160;
299                         break;
300                 }
301                 /* fall through */
302         case NL80211_CHAN_WIDTH_80:
303                 bw = IEEE80211_STA_RX_BW_80;
304         }
305
306  check_max:
307         if (bw > sta->cur_max_bandwidth)
308                 bw = sta->cur_max_bandwidth;
309         return bw;
310 }
311
312 void ieee80211_sta_set_rx_nss(struct sta_info *sta)
313 {
314         u8 ht_rx_nss = 0, vht_rx_nss = 0;
315
316         /* if we received a notification already don't overwrite it */
317         if (sta->sta.rx_nss)
318                 return;
319
320         if (sta->sta.ht_cap.ht_supported) {
321                 if (sta->sta.ht_cap.mcs.rx_mask[0])
322                         ht_rx_nss++;
323                 if (sta->sta.ht_cap.mcs.rx_mask[1])
324                         ht_rx_nss++;
325                 if (sta->sta.ht_cap.mcs.rx_mask[2])
326                         ht_rx_nss++;
327                 if (sta->sta.ht_cap.mcs.rx_mask[3])
328                         ht_rx_nss++;
329                 /* FIXME: consider rx_highest? */
330         }
331
332         if (sta->sta.vht_cap.vht_supported) {
333                 int i;
334                 u16 rx_mcs_map;
335
336                 rx_mcs_map = le16_to_cpu(sta->sta.vht_cap.vht_mcs.rx_mcs_map);
337
338                 for (i = 7; i >= 0; i--) {
339                         u8 mcs = (rx_mcs_map >> (2 * i)) & 3;
340
341                         if (mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) {
342                                 vht_rx_nss = i + 1;
343                                 break;
344                         }
345                 }
346                 /* FIXME: consider rx_highest? */
347         }
348
349         ht_rx_nss = max(ht_rx_nss, vht_rx_nss);
350         sta->sta.rx_nss = max_t(u8, 1, ht_rx_nss);
351 }
352
353 void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata,
354                                  struct sta_info *sta, u8 opmode,
355                                  enum ieee80211_band band, bool nss_only)
356 {
357         struct ieee80211_local *local = sdata->local;
358         struct ieee80211_supported_band *sband;
359         enum ieee80211_sta_rx_bandwidth new_bw;
360         u32 changed = 0;
361         u8 nss;
362
363         sband = local->hw.wiphy->bands[band];
364
365         /* ignore - no support for BF yet */
366         if (opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF)
367                 return;
368
369         nss = opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_MASK;
370         nss >>= IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT;
371         nss += 1;
372
373         if (sta->sta.rx_nss != nss) {
374                 sta->sta.rx_nss = nss;
375                 changed |= IEEE80211_RC_NSS_CHANGED;
376         }
377
378         if (nss_only)
379                 goto change;
380
381         switch (opmode & IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK) {
382         case IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ:
383                 sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_20;
384                 break;
385         case IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ:
386                 sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_40;
387                 break;
388         case IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ:
389                 sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_80;
390                 break;
391         case IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ:
392                 sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_160;
393                 break;
394         }
395
396         new_bw = ieee80211_sta_cur_vht_bw(sta);
397         if (new_bw != sta->sta.bandwidth) {
398                 sta->sta.bandwidth = new_bw;
399                 changed |= IEEE80211_RC_NSS_CHANGED;
400         }
401
402  change:
403         if (changed)
404                 rate_control_rate_update(local, sband, sta, changed);
405 }