1 /* 2 * hostapd / IEEE 802.11ac VHT 3 * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of BSD license 7 * 8 * See README and COPYING for more details. 9 */ 10 11 #include "utils/includes.h" 12 13 #include "utils/common.h" 14 #include "common/ieee802_11_defs.h" 15 #include "hostapd.h" 16 #include "ap_config.h" 17 #include "sta_info.h" 18 #include "beacon.h" 19 #include "ieee802_11.h" 20 #include "dfs.h" 21 22 23 u8 * hostapd_eid_vht_capabilities(struct hostapd_data *hapd, u8 *eid, u32 nsts) 24 { 25 struct ieee80211_vht_capabilities *cap; 26 struct hostapd_hw_modes *mode = hapd->iface->current_mode; 27 u8 *pos = eid; 28 29 if (!mode) 30 return eid; 31 32 if (mode->mode == HOSTAPD_MODE_IEEE80211G && hapd->conf->vendor_vht && 33 mode->vht_capab == 0 && hapd->iface->hw_features) { 34 int i; 35 36 for (i = 0; i < hapd->iface->num_hw_features; i++) { 37 if (hapd->iface->hw_features[i].mode == 38 HOSTAPD_MODE_IEEE80211A) { 39 mode = &hapd->iface->hw_features[i]; 40 break; 41 } 42 } 43 } 44 45 *pos++ = WLAN_EID_VHT_CAP; 46 *pos++ = sizeof(*cap); 47 48 cap = (struct ieee80211_vht_capabilities *) pos; 49 os_memset(cap, 0, sizeof(*cap)); 50 cap->vht_capabilities_info = host_to_le32( 51 hapd->iface->conf->vht_capab); 52 53 if (nsts != 0) { 54 u32 hapd_nsts; 55 56 hapd_nsts = le_to_host32(cap->vht_capabilities_info); 57 hapd_nsts = (hapd_nsts >> VHT_CAP_BEAMFORMEE_STS_OFFSET) & 7; 58 cap->vht_capabilities_info &= 59 ~(host_to_le32(hapd_nsts << 60 VHT_CAP_BEAMFORMEE_STS_OFFSET)); 61 cap->vht_capabilities_info |= 62 host_to_le32(nsts << VHT_CAP_BEAMFORMEE_STS_OFFSET); 63 } 64 65 /* Supported MCS set comes from hw */ 66 os_memcpy(&cap->vht_supported_mcs_set, mode->vht_mcs_set, 8); 67 68 pos += sizeof(*cap); 69 70 return pos; 71 } 72 73 74 u8 * hostapd_eid_vht_operation(struct hostapd_data *hapd, u8 *eid) 75 { 76 struct ieee80211_vht_operation *oper; 77 u8 *pos = eid; 78 79 *pos++ = WLAN_EID_VHT_OPERATION; 80 *pos++ = sizeof(*oper); 81 82 oper = (struct ieee80211_vht_operation *) pos; 83 os_memset(oper, 0, sizeof(*oper)); 84 85 /* 86 * center freq = 5 GHz + (5 * index) 87 * So index 42 gives center freq 5.210 GHz 88 * which is channel 42 in 5G band 89 */ 90 oper->vht_op_info_chan_center_freq_seg0_idx = 91 hapd->iconf->vht_oper_centr_freq_seg0_idx; 92 oper->vht_op_info_chan_center_freq_seg1_idx = 93 hapd->iconf->vht_oper_centr_freq_seg1_idx; 94 95 oper->vht_op_info_chwidth = hapd->iconf->vht_oper_chwidth; 96 if (hapd->iconf->vht_oper_chwidth == 2) { 97 /* 98 * Convert 160 MHz channel width to new style as interop 99 * workaround. 100 */ 101 oper->vht_op_info_chwidth = 1; 102 oper->vht_op_info_chan_center_freq_seg1_idx = 103 oper->vht_op_info_chan_center_freq_seg0_idx; 104 if (hapd->iconf->channel < 105 hapd->iconf->vht_oper_centr_freq_seg0_idx) 106 oper->vht_op_info_chan_center_freq_seg0_idx -= 8; 107 else 108 oper->vht_op_info_chan_center_freq_seg0_idx += 8; 109 } else if (hapd->iconf->vht_oper_chwidth == 3) { 110 /* 111 * Convert 80+80 MHz channel width to new style as interop 112 * workaround. 113 */ 114 oper->vht_op_info_chwidth = 1; 115 } 116 117 /* VHT Basic MCS set comes from hw */ 118 /* Hard code 1 stream, MCS0-7 is a min Basic VHT MCS rates */ 119 oper->vht_basic_mcs_set = host_to_le16(0xfffc); 120 pos += sizeof(*oper); 121 122 return pos; 123 } 124 125 126 static int check_valid_vht_mcs(struct hostapd_hw_modes *mode, 127 const u8 *sta_vht_capab) 128 { 129 const struct ieee80211_vht_capabilities *vht_cap; 130 struct ieee80211_vht_capabilities ap_vht_cap; 131 u16 sta_rx_mcs_set, ap_tx_mcs_set; 132 int i; 133 134 if (!mode) 135 return 1; 136 137 /* 138 * Disable VHT caps for STAs for which there is not even a single 139 * allowed MCS in any supported number of streams, i.e., STA is 140 * advertising 3 (not supported) as VHT MCS rates for all supported 141 * stream cases. 142 */ 143 os_memcpy(&ap_vht_cap.vht_supported_mcs_set, mode->vht_mcs_set, 144 sizeof(ap_vht_cap.vht_supported_mcs_set)); 145 vht_cap = (const struct ieee80211_vht_capabilities *) sta_vht_capab; 146 147 /* AP Tx MCS map vs. STA Rx MCS map */ 148 sta_rx_mcs_set = le_to_host16(vht_cap->vht_supported_mcs_set.rx_map); 149 ap_tx_mcs_set = le_to_host16(ap_vht_cap.vht_supported_mcs_set.tx_map); 150 151 for (i = 0; i < VHT_RX_NSS_MAX_STREAMS; i++) { 152 if ((ap_tx_mcs_set & (0x3 << (i * 2))) == 3) 153 continue; 154 155 if ((sta_rx_mcs_set & (0x3 << (i * 2))) == 3) 156 continue; 157 158 return 1; 159 } 160 161 wpa_printf(MSG_DEBUG, 162 "No matching VHT MCS found between AP TX and STA RX"); 163 return 0; 164 } 165 166 167 u8 * hostapd_eid_wb_chsw_wrapper(struct hostapd_data *hapd, u8 *eid) 168 { 169 u8 bw, chan1, chan2 = 0; 170 int freq1; 171 172 if (!hapd->cs_freq_params.channel || 173 !hapd->cs_freq_params.vht_enabled) 174 return eid; 175 176 /* bandwidth: 0: 40, 1: 80, 2: 160, 3: 80+80 */ 177 switch (hapd->cs_freq_params.bandwidth) { 178 case 40: 179 bw = 0; 180 break; 181 case 80: 182 /* check if it's 80+80 */ 183 if (!hapd->cs_freq_params.center_freq2) 184 bw = 1; 185 else 186 bw = 3; 187 break; 188 case 160: 189 bw = 2; 190 break; 191 default: 192 /* not valid VHT bandwidth or not in CSA */ 193 return eid; 194 } 195 196 freq1 = hapd->cs_freq_params.center_freq1 ? 197 hapd->cs_freq_params.center_freq1 : 198 hapd->cs_freq_params.freq; 199 if (ieee80211_freq_to_chan(freq1, &chan1) != 200 HOSTAPD_MODE_IEEE80211A) 201 return eid; 202 203 if (hapd->cs_freq_params.center_freq2 && 204 ieee80211_freq_to_chan(hapd->cs_freq_params.center_freq2, 205 &chan2) != HOSTAPD_MODE_IEEE80211A) 206 return eid; 207 208 *eid++ = WLAN_EID_VHT_CHANNEL_SWITCH_WRAPPER; 209 *eid++ = 5; /* Length of Channel Switch Wrapper */ 210 *eid++ = WLAN_EID_VHT_WIDE_BW_CHSWITCH; 211 *eid++ = 3; /* Length of Wide Bandwidth Channel Switch element */ 212 *eid++ = bw; /* New Channel Width */ 213 *eid++ = chan1; /* New Channel Center Frequency Segment 0 */ 214 *eid++ = chan2; /* New Channel Center Frequency Segment 1 */ 215 216 return eid; 217 } 218 219 220 u8 * hostapd_eid_txpower_envelope(struct hostapd_data *hapd, u8 *eid) 221 { 222 struct hostapd_iface *iface = hapd->iface; 223 struct hostapd_config *iconf = iface->conf; 224 struct hostapd_hw_modes *mode = iface->current_mode; 225 struct hostapd_channel_data *chan; 226 int dfs, i; 227 u8 channel, tx_pwr_count, local_pwr_constraint; 228 int max_tx_power; 229 u8 tx_pwr; 230 231 if (!mode) 232 return eid; 233 234 if (ieee80211_freq_to_chan(iface->freq, &channel) == NUM_HOSTAPD_MODES) 235 return eid; 236 237 for (i = 0; i < mode->num_channels; i++) { 238 if (mode->channels[i].freq == iface->freq) 239 break; 240 } 241 if (i == mode->num_channels) 242 return eid; 243 244 switch (iface->conf->vht_oper_chwidth) { 245 case CHANWIDTH_USE_HT: 246 if (iconf->secondary_channel == 0) { 247 /* Max Transmit Power count = 0 (20 MHz) */ 248 tx_pwr_count = 0; 249 } else { 250 /* Max Transmit Power count = 1 (20, 40 MHz) */ 251 tx_pwr_count = 1; 252 } 253 break; 254 case CHANWIDTH_80MHZ: 255 /* Max Transmit Power count = 2 (20, 40, and 80 MHz) */ 256 tx_pwr_count = 2; 257 break; 258 case CHANWIDTH_80P80MHZ: 259 case CHANWIDTH_160MHZ: 260 /* Max Transmit Power count = 3 (20, 40, 80, 160/80+80 MHz) */ 261 tx_pwr_count = 3; 262 break; 263 default: 264 return eid; 265 } 266 267 /* 268 * Below local_pwr_constraint logic is referred from 269 * hostapd_eid_pwr_constraint. 270 * 271 * Check if DFS is required by regulatory. 272 */ 273 dfs = hostapd_is_dfs_required(hapd->iface); 274 if (dfs < 0) 275 dfs = 0; 276 277 /* 278 * In order to meet regulations when TPC is not implemented using 279 * a transmit power that is below the legal maximum (including any 280 * mitigation factor) should help. In this case, indicate 3 dB below 281 * maximum allowed transmit power. 282 */ 283 if (hapd->iconf->local_pwr_constraint == -1) 284 local_pwr_constraint = (dfs == 0) ? 0 : 3; 285 else 286 local_pwr_constraint = hapd->iconf->local_pwr_constraint; 287 288 /* 289 * A STA that is not an AP shall use a transmit power less than or 290 * equal to the local maximum transmit power level for the channel. 291 * The local maximum transmit power can be calculated from the formula: 292 * local max TX pwr = max TX pwr - local pwr constraint 293 * Where max TX pwr is maximum transmit power level specified for 294 * channel in Country element and local pwr constraint is specified 295 * for channel in this Power Constraint element. 296 */ 297 chan = &mode->channels[i]; 298 max_tx_power = chan->max_tx_power - local_pwr_constraint; 299 300 /* 301 * Local Maximum Transmit power is encoded as two's complement 302 * with a 0.5 dB step. 303 */ 304 max_tx_power *= 2; /* in 0.5 dB steps */ 305 if (max_tx_power > 127) { 306 /* 63.5 has special meaning of 63.5 dBm or higher */ 307 max_tx_power = 127; 308 } 309 if (max_tx_power < -128) 310 max_tx_power = -128; 311 if (max_tx_power < 0) 312 tx_pwr = 0x80 + max_tx_power + 128; 313 else 314 tx_pwr = max_tx_power; 315 316 *eid++ = WLAN_EID_VHT_TRANSMIT_POWER_ENVELOPE; 317 *eid++ = 2 + tx_pwr_count; 318 319 /* 320 * Max Transmit Power count and 321 * Max Transmit Power units = 0 (EIRP) 322 */ 323 *eid++ = tx_pwr_count; 324 325 for (i = 0; i <= tx_pwr_count; i++) 326 *eid++ = tx_pwr; 327 328 return eid; 329 } 330 331 332 u16 copy_sta_vht_capab(struct hostapd_data *hapd, struct sta_info *sta, 333 const u8 *vht_capab) 334 { 335 /* Disable VHT caps for STAs associated to no-VHT BSSes. */ 336 if (!vht_capab || 337 !hapd->iconf->ieee80211ac || hapd->conf->disable_11ac || 338 !check_valid_vht_mcs(hapd->iface->current_mode, vht_capab)) { 339 sta->flags &= ~WLAN_STA_VHT; 340 os_free(sta->vht_capabilities); 341 sta->vht_capabilities = NULL; 342 return WLAN_STATUS_SUCCESS; 343 } 344 345 if (sta->vht_capabilities == NULL) { 346 sta->vht_capabilities = 347 os_zalloc(sizeof(struct ieee80211_vht_capabilities)); 348 if (sta->vht_capabilities == NULL) 349 return WLAN_STATUS_UNSPECIFIED_FAILURE; 350 } 351 352 sta->flags |= WLAN_STA_VHT; 353 os_memcpy(sta->vht_capabilities, vht_capab, 354 sizeof(struct ieee80211_vht_capabilities)); 355 356 return WLAN_STATUS_SUCCESS; 357 } 358 359 360 u16 copy_sta_vht_oper(struct hostapd_data *hapd, struct sta_info *sta, 361 const u8 *vht_oper) 362 { 363 if (!vht_oper) { 364 os_free(sta->vht_operation); 365 sta->vht_operation = NULL; 366 return WLAN_STATUS_SUCCESS; 367 } 368 369 if (!sta->vht_operation) { 370 sta->vht_operation = 371 os_zalloc(sizeof(struct ieee80211_vht_operation)); 372 if (!sta->vht_operation) 373 return WLAN_STATUS_UNSPECIFIED_FAILURE; 374 } 375 376 os_memcpy(sta->vht_operation, vht_oper, 377 sizeof(struct ieee80211_vht_operation)); 378 379 return WLAN_STATUS_SUCCESS; 380 } 381 382 383 u16 copy_sta_vendor_vht(struct hostapd_data *hapd, struct sta_info *sta, 384 const u8 *ie, size_t len) 385 { 386 const u8 *vht_capab; 387 unsigned int vht_capab_len; 388 389 if (!ie || len < 5 + 2 + sizeof(struct ieee80211_vht_capabilities) || 390 hapd->conf->disable_11ac) 391 goto no_capab; 392 393 /* The VHT Capabilities element embedded in vendor VHT */ 394 vht_capab = ie + 5; 395 if (vht_capab[0] != WLAN_EID_VHT_CAP) 396 goto no_capab; 397 vht_capab_len = vht_capab[1]; 398 if (vht_capab_len < sizeof(struct ieee80211_vht_capabilities) || 399 (int) vht_capab_len > ie + len - vht_capab - 2) 400 goto no_capab; 401 vht_capab += 2; 402 403 if (sta->vht_capabilities == NULL) { 404 sta->vht_capabilities = 405 os_zalloc(sizeof(struct ieee80211_vht_capabilities)); 406 if (sta->vht_capabilities == NULL) 407 return WLAN_STATUS_UNSPECIFIED_FAILURE; 408 } 409 410 sta->flags |= WLAN_STA_VHT | WLAN_STA_VENDOR_VHT; 411 os_memcpy(sta->vht_capabilities, vht_capab, 412 sizeof(struct ieee80211_vht_capabilities)); 413 return WLAN_STATUS_SUCCESS; 414 415 no_capab: 416 sta->flags &= ~WLAN_STA_VENDOR_VHT; 417 return WLAN_STATUS_SUCCESS; 418 } 419 420 421 u8 * hostapd_eid_vendor_vht(struct hostapd_data *hapd, u8 *eid) 422 { 423 u8 *pos = eid; 424 425 if (!hapd->iface->current_mode) 426 return eid; 427 428 *pos++ = WLAN_EID_VENDOR_SPECIFIC; 429 *pos++ = (5 + /* The Vendor OUI, type and subtype */ 430 2 + sizeof(struct ieee80211_vht_capabilities) + 431 2 + sizeof(struct ieee80211_vht_operation)); 432 433 WPA_PUT_BE32(pos, (OUI_BROADCOM << 8) | VENDOR_VHT_TYPE); 434 pos += 4; 435 *pos++ = VENDOR_VHT_SUBTYPE; 436 pos = hostapd_eid_vht_capabilities(hapd, pos, 0); 437 pos = hostapd_eid_vht_operation(hapd, pos); 438 439 return pos; 440 } 441 442 443 u16 set_sta_vht_opmode(struct hostapd_data *hapd, struct sta_info *sta, 444 const u8 *vht_oper_notif) 445 { 446 if (!vht_oper_notif) { 447 sta->flags &= ~WLAN_STA_VHT_OPMODE_ENABLED; 448 return WLAN_STATUS_SUCCESS; 449 } 450 451 sta->flags |= WLAN_STA_VHT_OPMODE_ENABLED; 452 sta->vht_opmode = *vht_oper_notif; 453 return WLAN_STATUS_SUCCESS; 454 } 455 456 457 void hostapd_get_vht_capab(struct hostapd_data *hapd, 458 struct ieee80211_vht_capabilities *vht_cap, 459 struct ieee80211_vht_capabilities *neg_vht_cap) 460 { 461 u32 cap, own_cap, sym_caps; 462 463 if (vht_cap == NULL) 464 return; 465 os_memcpy(neg_vht_cap, vht_cap, sizeof(*neg_vht_cap)); 466 467 cap = le_to_host32(neg_vht_cap->vht_capabilities_info); 468 own_cap = hapd->iconf->vht_capab; 469 470 /* mask out symmetric VHT capabilities we don't support */ 471 sym_caps = VHT_CAP_SHORT_GI_80 | VHT_CAP_SHORT_GI_160; 472 cap &= ~sym_caps | (own_cap & sym_caps); 473 474 /* mask out beamformer/beamformee caps if not supported */ 475 if (!(own_cap & VHT_CAP_SU_BEAMFORMER_CAPABLE)) 476 cap &= ~(VHT_CAP_SU_BEAMFORMEE_CAPABLE | 477 VHT_CAP_BEAMFORMEE_STS_MAX); 478 479 if (!(own_cap & VHT_CAP_SU_BEAMFORMEE_CAPABLE)) 480 cap &= ~(VHT_CAP_SU_BEAMFORMER_CAPABLE | 481 VHT_CAP_SOUNDING_DIMENSION_MAX); 482 483 if (!(own_cap & VHT_CAP_MU_BEAMFORMER_CAPABLE)) 484 cap &= ~VHT_CAP_MU_BEAMFORMEE_CAPABLE; 485 486 if (!(own_cap & VHT_CAP_MU_BEAMFORMEE_CAPABLE)) 487 cap &= ~VHT_CAP_MU_BEAMFORMER_CAPABLE; 488 489 /* mask channel widths we don't support */ 490 switch (own_cap & VHT_CAP_SUPP_CHAN_WIDTH_MASK) { 491 case VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ: 492 break; 493 case VHT_CAP_SUPP_CHAN_WIDTH_160MHZ: 494 if (cap & VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) { 495 cap &= ~VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ; 496 cap |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ; 497 } 498 break; 499 default: 500 cap &= ~VHT_CAP_SUPP_CHAN_WIDTH_MASK; 501 break; 502 } 503 504 if (!(cap & VHT_CAP_SUPP_CHAN_WIDTH_MASK)) 505 cap &= ~VHT_CAP_SHORT_GI_160; 506 507 /* 508 * if we don't support RX STBC, mask out TX STBC in the STA's HT caps 509 * if we don't support TX STBC, mask out RX STBC in the STA's HT caps 510 */ 511 if (!(own_cap & VHT_CAP_RXSTBC_MASK)) 512 cap &= ~VHT_CAP_TXSTBC; 513 if (!(own_cap & VHT_CAP_TXSTBC)) 514 cap &= ~VHT_CAP_RXSTBC_MASK; 515 516 neg_vht_cap->vht_capabilities_info = host_to_le32(cap); 517 } 518