Mahesh Palivela | 818255e | 2012-10-10 11:33:04 +0000 | [diff] [blame] | 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" |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 13 | #include "rate.h" |
Mahesh Palivela | 818255e | 2012-10-10 11:33:04 +0000 | [diff] [blame] | 14 | |
| 15 | |
Johannes Berg | dd5ecfe | 2013-02-21 17:40:19 +0100 | [diff] [blame^] | 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 | |
Johannes Berg | 4a3cb70 | 2013-02-12 16:43:19 +0100 | [diff] [blame] | 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) |
Mahesh Palivela | 818255e | 2012-10-10 11:33:04 +0000 | [diff] [blame] | 119 | { |
Johannes Berg | 4a34215 | 2013-02-07 11:58:58 +0100 | [diff] [blame] | 120 | struct ieee80211_sta_vht_cap *vht_cap = &sta->sta.vht_cap; |
Mahesh Palivela | 818255e | 2012-10-10 11:33:04 +0000 | [diff] [blame] | 121 | |
| 122 | memset(vht_cap, 0, sizeof(*vht_cap)); |
| 123 | |
Johannes Berg | 4a34215 | 2013-02-07 11:58:58 +0100 | [diff] [blame] | 124 | if (!sta->sta.ht_cap.ht_supported) |
| 125 | return; |
| 126 | |
Mahesh Palivela | 818255e | 2012-10-10 11:33:04 +0000 | [diff] [blame] | 127 | if (!vht_cap_ie || !sband->vht_cap.vht_supported) |
| 128 | return; |
| 129 | |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 130 | /* A VHT STA must support 40 MHz */ |
| 131 | if (!(sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) |
| 132 | return; |
| 133 | |
Mahesh Palivela | 818255e | 2012-10-10 11:33:04 +0000 | [diff] [blame] | 134 | vht_cap->vht_supported = true; |
| 135 | |
| 136 | vht_cap->cap = le32_to_cpu(vht_cap_ie->vht_cap_info); |
| 137 | |
| 138 | /* Copy peer MCS info, the driver might need them. */ |
| 139 | memcpy(&vht_cap->vht_mcs, &vht_cap_ie->supp_mcs, |
| 140 | sizeof(struct ieee80211_vht_mcs_info)); |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 141 | |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 142 | switch (vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) { |
| 143 | case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ: |
| 144 | case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ: |
| 145 | sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_160; |
| 146 | break; |
| 147 | default: |
| 148 | sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_80; |
| 149 | } |
| 150 | |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 151 | sta->sta.bandwidth = ieee80211_sta_cur_vht_bw(sta); |
| 152 | } |
| 153 | |
| 154 | enum ieee80211_sta_rx_bandwidth ieee80211_sta_cur_vht_bw(struct sta_info *sta) |
| 155 | { |
| 156 | struct ieee80211_sub_if_data *sdata = sta->sdata; |
| 157 | u32 cap = sta->sta.vht_cap.cap; |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 158 | enum ieee80211_sta_rx_bandwidth bw; |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 159 | |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 160 | if (!sta->sta.vht_cap.vht_supported) { |
| 161 | bw = sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ? |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 162 | IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20; |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 163 | goto check_max; |
| 164 | } |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 165 | |
| 166 | switch (sdata->vif.bss_conf.chandef.width) { |
| 167 | default: |
| 168 | WARN_ON_ONCE(1); |
| 169 | /* fall through */ |
| 170 | case NL80211_CHAN_WIDTH_20_NOHT: |
| 171 | case NL80211_CHAN_WIDTH_20: |
| 172 | case NL80211_CHAN_WIDTH_40: |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 173 | bw = sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ? |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 174 | IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20; |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 175 | break; |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 176 | case NL80211_CHAN_WIDTH_160: |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 177 | if ((cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) == |
| 178 | IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ) { |
| 179 | bw = IEEE80211_STA_RX_BW_160; |
| 180 | break; |
| 181 | } |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 182 | /* fall through */ |
| 183 | case NL80211_CHAN_WIDTH_80P80: |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 184 | if ((cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) == |
| 185 | IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) { |
| 186 | bw = IEEE80211_STA_RX_BW_160; |
| 187 | break; |
| 188 | } |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 189 | /* fall through */ |
| 190 | case NL80211_CHAN_WIDTH_80: |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 191 | bw = IEEE80211_STA_RX_BW_80; |
Johannes Berg | e1a0c6b | 2013-02-07 11:47:44 +0100 | [diff] [blame] | 192 | } |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 193 | |
| 194 | check_max: |
| 195 | if (bw > sta->cur_max_bandwidth) |
| 196 | bw = sta->cur_max_bandwidth; |
| 197 | return bw; |
Mahesh Palivela | 818255e | 2012-10-10 11:33:04 +0000 | [diff] [blame] | 198 | } |
Johannes Berg | 8921d04 | 2012-12-27 18:26:42 +0100 | [diff] [blame] | 199 | |
| 200 | void ieee80211_sta_set_rx_nss(struct sta_info *sta) |
| 201 | { |
| 202 | u8 ht_rx_nss = 0, vht_rx_nss = 0; |
| 203 | |
| 204 | /* if we received a notification already don't overwrite it */ |
| 205 | if (sta->sta.rx_nss) |
| 206 | return; |
| 207 | |
| 208 | if (sta->sta.ht_cap.ht_supported) { |
| 209 | if (sta->sta.ht_cap.mcs.rx_mask[0]) |
| 210 | ht_rx_nss++; |
| 211 | if (sta->sta.ht_cap.mcs.rx_mask[1]) |
| 212 | ht_rx_nss++; |
| 213 | if (sta->sta.ht_cap.mcs.rx_mask[2]) |
| 214 | ht_rx_nss++; |
| 215 | if (sta->sta.ht_cap.mcs.rx_mask[3]) |
| 216 | ht_rx_nss++; |
| 217 | /* FIXME: consider rx_highest? */ |
| 218 | } |
| 219 | |
| 220 | if (sta->sta.vht_cap.vht_supported) { |
| 221 | int i; |
| 222 | u16 rx_mcs_map; |
| 223 | |
| 224 | rx_mcs_map = le16_to_cpu(sta->sta.vht_cap.vht_mcs.rx_mcs_map); |
| 225 | |
| 226 | for (i = 7; i >= 0; i--) { |
| 227 | u8 mcs = (rx_mcs_map >> (2 * i)) & 3; |
| 228 | |
| 229 | if (mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) { |
| 230 | vht_rx_nss = i + 1; |
| 231 | break; |
| 232 | } |
| 233 | } |
| 234 | /* FIXME: consider rx_highest? */ |
| 235 | } |
| 236 | |
| 237 | ht_rx_nss = max(ht_rx_nss, vht_rx_nss); |
| 238 | sta->sta.rx_nss = max_t(u8, 1, ht_rx_nss); |
| 239 | } |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 240 | |
| 241 | void ieee80211_vht_handle_opmode(struct ieee80211_sub_if_data *sdata, |
| 242 | struct sta_info *sta, u8 opmode, |
Johannes Berg | bee7f58 | 2013-02-07 22:24:55 +0100 | [diff] [blame] | 243 | enum ieee80211_band band, bool nss_only) |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 244 | { |
| 245 | struct ieee80211_local *local = sdata->local; |
| 246 | struct ieee80211_supported_band *sband; |
| 247 | enum ieee80211_sta_rx_bandwidth new_bw; |
| 248 | u32 changed = 0; |
| 249 | u8 nss; |
| 250 | |
| 251 | sband = local->hw.wiphy->bands[band]; |
| 252 | |
| 253 | /* ignore - no support for BF yet */ |
| 254 | if (opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF) |
| 255 | return; |
| 256 | |
| 257 | nss = opmode & IEEE80211_OPMODE_NOTIF_RX_NSS_MASK; |
| 258 | nss >>= IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT; |
| 259 | nss += 1; |
| 260 | |
| 261 | if (sta->sta.rx_nss != nss) { |
| 262 | sta->sta.rx_nss = nss; |
| 263 | changed |= IEEE80211_RC_NSS_CHANGED; |
| 264 | } |
| 265 | |
Johannes Berg | bee7f58 | 2013-02-07 22:24:55 +0100 | [diff] [blame] | 266 | if (nss_only) |
| 267 | goto change; |
| 268 | |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 269 | switch (opmode & IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK) { |
| 270 | case IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ: |
| 271 | sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_20; |
| 272 | break; |
| 273 | case IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ: |
| 274 | sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_40; |
| 275 | break; |
| 276 | case IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ: |
| 277 | sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_80; |
| 278 | break; |
| 279 | case IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ: |
| 280 | sta->cur_max_bandwidth = IEEE80211_STA_RX_BW_160; |
| 281 | break; |
| 282 | } |
| 283 | |
| 284 | new_bw = ieee80211_sta_cur_vht_bw(sta); |
| 285 | if (new_bw != sta->sta.bandwidth) { |
| 286 | sta->sta.bandwidth = new_bw; |
| 287 | changed |= IEEE80211_RC_NSS_CHANGED; |
| 288 | } |
| 289 | |
Johannes Berg | bee7f58 | 2013-02-07 22:24:55 +0100 | [diff] [blame] | 290 | change: |
Johannes Berg | 0af83d3 | 2012-12-27 18:55:36 +0100 | [diff] [blame] | 291 | if (changed) |
| 292 | rate_control_rate_update(local, sband, sta, changed); |
| 293 | } |