1/* 2 * Common hostapd/wpa_supplicant HW features 3 * Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi> 4 * Copyright (c) 2015, Qualcomm Atheros, Inc. 5 * 6 * This software may be distributed under the terms of the BSD license. 7 * See README for more details. 8 */ 9 10#include "includes.h" 11 12#include "common.h" 13#include "defs.h" 14#include "ieee802_11_defs.h" 15#include "ieee802_11_common.h" 16#include "hw_features_common.h" 17 18 19struct hostapd_channel_data * hw_get_channel_chan(struct hostapd_hw_modes *mode, 20 int chan, int *freq) 21{ 22 int i; 23 24 if (freq) 25 *freq = 0; 26 27 if (!mode) 28 return NULL; 29 30 for (i = 0; i < mode->num_channels; i++) { 31 struct hostapd_channel_data *ch = &mode->channels[i]; 32 if (ch->chan == chan) { 33 if (freq) 34 *freq = ch->freq; 35 return ch; 36 } 37 } 38 39 return NULL; 40} 41 42 43struct hostapd_channel_data * hw_get_channel_freq(struct hostapd_hw_modes *mode, 44 int freq, int *chan) 45{ 46 int i; 47 48 if (chan) 49 *chan = 0; 50 51 if (!mode) 52 return NULL; 53 54 for (i = 0; i < mode->num_channels; i++) { 55 struct hostapd_channel_data *ch = &mode->channels[i]; 56 if (ch->freq == freq) { 57 if (chan) 58 *chan = ch->chan; 59 return ch; 60 } 61 } 62 63 return NULL; 64} 65 66 67int hw_get_freq(struct hostapd_hw_modes *mode, int chan) 68{ 69 int freq; 70 71 hw_get_channel_chan(mode, chan, &freq); 72 73 return freq; 74} 75 76 77int hw_get_chan(struct hostapd_hw_modes *mode, int freq) 78{ 79 int chan; 80 81 hw_get_channel_freq(mode, freq, &chan); 82 83 return chan; 84} 85 86 87int allowed_ht40_channel_pair(struct hostapd_hw_modes *mode, int pri_chan, 88 int sec_chan) 89{ 90 int ok, j, first; 91 int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 140, 92 149, 157, 184, 192 }; 93 size_t k; 94 95 if (pri_chan == sec_chan || !sec_chan) 96 return 1; /* HT40 not used */ 97 98 wpa_printf(MSG_DEBUG, 99 "HT40: control channel: %d secondary channel: %d", 100 pri_chan, sec_chan); 101 102 /* Verify that HT40 secondary channel is an allowed 20 MHz 103 * channel */ 104 ok = 0; 105 for (j = 0; j < mode->num_channels; j++) { 106 struct hostapd_channel_data *chan = &mode->channels[j]; 107 if (!(chan->flag & HOSTAPD_CHAN_DISABLED) && 108 chan->chan == sec_chan) { 109 ok = 1; 110 break; 111 } 112 } 113 if (!ok) { 114 wpa_printf(MSG_ERROR, "HT40 secondary channel %d not allowed", 115 sec_chan); 116 return 0; 117 } 118 119 /* 120 * Verify that HT40 primary,secondary channel pair is allowed per 121 * IEEE 802.11n Annex J. This is only needed for 5 GHz band since 122 * 2.4 GHz rules allow all cases where the secondary channel fits into 123 * the list of allowed channels (already checked above). 124 */ 125 if (mode->mode != HOSTAPD_MODE_IEEE80211A) 126 return 1; 127 128 first = pri_chan < sec_chan ? pri_chan : sec_chan; 129 130 ok = 0; 131 for (k = 0; k < ARRAY_SIZE(allowed); k++) { 132 if (first == allowed[k]) { 133 ok = 1; 134 break; 135 } 136 } 137 if (!ok) { 138 wpa_printf(MSG_ERROR, "HT40 channel pair (%d, %d) not allowed", 139 pri_chan, sec_chan); 140 return 0; 141 } 142 143 return 1; 144} 145 146 147void get_pri_sec_chan(struct wpa_scan_res *bss, int *pri_chan, int *sec_chan) 148{ 149 struct ieee80211_ht_operation *oper; 150 struct ieee802_11_elems elems; 151 152 *pri_chan = *sec_chan = 0; 153 154 ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0); 155 if (elems.ht_operation) { 156 oper = (struct ieee80211_ht_operation *) elems.ht_operation; 157 *pri_chan = oper->primary_chan; 158 if (oper->ht_param & HT_INFO_HT_PARAM_STA_CHNL_WIDTH) { 159 int sec = oper->ht_param & 160 HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK; 161 if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_ABOVE) 162 *sec_chan = *pri_chan + 4; 163 else if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_BELOW) 164 *sec_chan = *pri_chan - 4; 165 } 166 } 167} 168 169 170int check_40mhz_5g(struct hostapd_hw_modes *mode, 171 struct wpa_scan_results *scan_res, int pri_chan, 172 int sec_chan) 173{ 174 int pri_freq, sec_freq, pri_bss, sec_bss; 175 int bss_pri_chan, bss_sec_chan; 176 size_t i; 177 int match; 178 179 if (!mode || !scan_res || !pri_chan || !sec_chan || 180 pri_chan == sec_chan) 181 return 0; 182 183 pri_freq = hw_get_freq(mode, pri_chan); 184 sec_freq = hw_get_freq(mode, sec_chan); 185 186 /* 187 * Switch PRI/SEC channels if Beacons were detected on selected SEC 188 * channel, but not on selected PRI channel. 189 */ 190 pri_bss = sec_bss = 0; 191 for (i = 0; i < scan_res->num; i++) { 192 struct wpa_scan_res *bss = scan_res->res[i]; 193 if (bss->freq == pri_freq) 194 pri_bss++; 195 else if (bss->freq == sec_freq) 196 sec_bss++; 197 } 198 if (sec_bss && !pri_bss) { 199 wpa_printf(MSG_INFO, 200 "Switch own primary and secondary channel to get secondary channel with no Beacons from other BSSes"); 201 return 2; 202 } 203 204 /* 205 * Match PRI/SEC channel with any existing HT40 BSS on the same 206 * channels that we are about to use (if already mixed order in 207 * existing BSSes, use own preference). 208 */ 209 match = 0; 210 for (i = 0; i < scan_res->num; i++) { 211 struct wpa_scan_res *bss = scan_res->res[i]; 212 get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan); 213 if (pri_chan == bss_pri_chan && 214 sec_chan == bss_sec_chan) { 215 match = 1; 216 break; 217 } 218 } 219 if (!match) { 220 for (i = 0; i < scan_res->num; i++) { 221 struct wpa_scan_res *bss = scan_res->res[i]; 222 get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan); 223 if (pri_chan == bss_sec_chan && 224 sec_chan == bss_pri_chan) { 225 wpa_printf(MSG_INFO, "Switch own primary and " 226 "secondary channel due to BSS " 227 "overlap with " MACSTR, 228 MAC2STR(bss->bssid)); 229 return 2; 230 } 231 } 232 } 233 234 return 1; 235} 236 237 238static int check_20mhz_bss(struct wpa_scan_res *bss, int pri_freq, int start, 239 int end) 240{ 241 struct ieee802_11_elems elems; 242 struct ieee80211_ht_operation *oper; 243 244 if (bss->freq < start || bss->freq > end || bss->freq == pri_freq) 245 return 0; 246 247 ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0); 248 if (!elems.ht_capabilities) { 249 wpa_printf(MSG_DEBUG, "Found overlapping legacy BSS: " 250 MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq); 251 return 1; 252 } 253 254 if (elems.ht_operation) { 255 oper = (struct ieee80211_ht_operation *) elems.ht_operation; 256 if (oper->ht_param & HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK) 257 return 0; 258 259 wpa_printf(MSG_DEBUG, "Found overlapping 20 MHz HT BSS: " 260 MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq); 261 return 1; 262 } 263 return 0; 264} 265 266 267int check_40mhz_2g4(struct hostapd_hw_modes *mode, 268 struct wpa_scan_results *scan_res, int pri_chan, 269 int sec_chan) 270{ 271 int pri_freq, sec_freq; 272 int affected_start, affected_end; 273 size_t i; 274 275 if (!mode || !scan_res || !pri_chan || !sec_chan || 276 pri_chan == sec_chan) 277 return 0; 278 279 pri_freq = hw_get_freq(mode, pri_chan); 280 sec_freq = hw_get_freq(mode, sec_chan); 281 282 affected_start = (pri_freq + sec_freq) / 2 - 25; 283 affected_end = (pri_freq + sec_freq) / 2 + 25; 284 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz", 285 affected_start, affected_end); 286 for (i = 0; i < scan_res->num; i++) { 287 struct wpa_scan_res *bss = scan_res->res[i]; 288 int pri = bss->freq; 289 int sec = pri; 290 struct ieee802_11_elems elems; 291 292 /* Check for overlapping 20 MHz BSS */ 293 if (check_20mhz_bss(bss, pri_freq, affected_start, 294 affected_end)) { 295 wpa_printf(MSG_DEBUG, 296 "Overlapping 20 MHz BSS is found"); 297 return 0; 298 } 299 300 get_pri_sec_chan(bss, &pri_chan, &sec_chan); 301 302 if (sec_chan) { 303 if (sec_chan < pri_chan) 304 sec = pri - 20; 305 else 306 sec = pri + 20; 307 } 308 309 if ((pri < affected_start || pri > affected_end) && 310 (sec < affected_start || sec > affected_end)) 311 continue; /* not within affected channel range */ 312 313 wpa_printf(MSG_DEBUG, "Neighboring BSS: " MACSTR 314 " freq=%d pri=%d sec=%d", 315 MAC2STR(bss->bssid), bss->freq, pri_chan, sec_chan); 316 317 if (sec_chan) { 318 if (pri_freq != pri || sec_freq != sec) { 319 wpa_printf(MSG_DEBUG, 320 "40 MHz pri/sec mismatch with BSS " 321 MACSTR 322 " <%d,%d> (chan=%d%c) vs. <%d,%d>", 323 MAC2STR(bss->bssid), 324 pri, sec, pri_chan, 325 sec > pri ? '+' : '-', 326 pri_freq, sec_freq); 327 return 0; 328 } 329 } 330 331 ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 332 0); 333 if (elems.ht_capabilities) { 334 struct ieee80211_ht_capabilities *ht_cap = 335 (struct ieee80211_ht_capabilities *) 336 elems.ht_capabilities; 337 338 if (le_to_host16(ht_cap->ht_capabilities_info) & 339 HT_CAP_INFO_40MHZ_INTOLERANT) { 340 wpa_printf(MSG_DEBUG, 341 "40 MHz Intolerant is set on channel %d in BSS " 342 MACSTR, pri, MAC2STR(bss->bssid)); 343 return 0; 344 } 345 } 346 } 347 348 return 1; 349} 350 351 352int hostapd_set_freq_params(struct hostapd_freq_params *data, 353 enum hostapd_hw_mode mode, 354 int freq, int channel, int ht_enabled, 355 int vht_enabled, int sec_channel_offset, 356 int vht_oper_chwidth, int center_segment0, 357 int center_segment1, u32 vht_caps) 358{ 359 os_memset(data, 0, sizeof(*data)); 360 data->mode = mode; 361 data->freq = freq; 362 data->channel = channel; 363 data->ht_enabled = ht_enabled; 364 data->vht_enabled = vht_enabled; 365 data->sec_channel_offset = sec_channel_offset; 366 data->center_freq1 = freq + sec_channel_offset * 10; 367 data->center_freq2 = 0; 368 data->bandwidth = sec_channel_offset ? 40 : 20; 369 370 if (data->vht_enabled) switch (vht_oper_chwidth) { 371 case VHT_CHANWIDTH_USE_HT: 372 if (center_segment1 || 373 (center_segment0 != 0 && 374 5000 + center_segment0 * 5 != data->center_freq1 && 375 2407 + center_segment0 * 5 != data->center_freq1)) 376 return -1; 377 break; 378 case VHT_CHANWIDTH_80P80MHZ: 379 if (!(vht_caps & VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) { 380 wpa_printf(MSG_ERROR, 381 "80+80 channel width is not supported!"); 382 return -1; 383 } 384 if (center_segment1 == center_segment0 + 4 || 385 center_segment1 == center_segment0 - 4) 386 return -1; 387 data->center_freq2 = 5000 + center_segment1 * 5; 388 /* fall through */ 389 case VHT_CHANWIDTH_80MHZ: 390 data->bandwidth = 80; 391 if ((vht_oper_chwidth == VHT_CHANWIDTH_80MHZ && 392 center_segment1) || 393 (vht_oper_chwidth == VHT_CHANWIDTH_80P80MHZ && 394 !center_segment1) || 395 !sec_channel_offset) 396 return -1; 397 if (!center_segment0) { 398 if (channel <= 48) 399 center_segment0 = 42; 400 else if (channel <= 64) 401 center_segment0 = 58; 402 else if (channel <= 112) 403 center_segment0 = 106; 404 else if (channel <= 128) 405 center_segment0 = 122; 406 else if (channel <= 144) 407 center_segment0 = 138; 408 else if (channel <= 161) 409 center_segment0 = 155; 410 data->center_freq1 = 5000 + center_segment0 * 5; 411 } else { 412 /* 413 * Note: HT/VHT config and params are coupled. Check if 414 * HT40 channel band is in VHT80 Pri channel band 415 * configuration. 416 */ 417 if (center_segment0 == channel + 6 || 418 center_segment0 == channel + 2 || 419 center_segment0 == channel - 2 || 420 center_segment0 == channel - 6) 421 data->center_freq1 = 5000 + center_segment0 * 5; 422 else 423 return -1; 424 } 425 break; 426 case VHT_CHANWIDTH_160MHZ: 427 data->bandwidth = 160; 428 if (!(vht_caps & (VHT_CAP_SUPP_CHAN_WIDTH_160MHZ | 429 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))) { 430 wpa_printf(MSG_ERROR, 431 "160MHZ channel width is not supported!"); 432 return -1; 433 } 434 if (center_segment1) 435 return -1; 436 if (!sec_channel_offset) 437 return -1; 438 /* 439 * Note: HT/VHT config and params are coupled. Check if 440 * HT40 channel band is in VHT160 channel band configuration. 441 */ 442 if (center_segment0 == channel + 14 || 443 center_segment0 == channel + 10 || 444 center_segment0 == channel + 6 || 445 center_segment0 == channel + 2 || 446 center_segment0 == channel - 2 || 447 center_segment0 == channel - 6 || 448 center_segment0 == channel - 10 || 449 center_segment0 == channel - 14) 450 data->center_freq1 = 5000 + center_segment0 * 5; 451 else 452 return -1; 453 break; 454 } 455 456 return 0; 457} 458 459 460void set_disable_ht40(struct ieee80211_ht_capabilities *htcaps, 461 int disabled) 462{ 463 /* Masking these out disables HT40 */ 464 le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET | 465 HT_CAP_INFO_SHORT_GI40MHZ); 466 467 if (disabled) 468 htcaps->ht_capabilities_info &= ~msk; 469 else 470 htcaps->ht_capabilities_info |= msk; 471} 472 473 474#ifdef CONFIG_IEEE80211AC 475 476static int _ieee80211ac_cap_check(u32 hw, u32 conf, u32 cap, 477 const char *name) 478{ 479 u32 req_cap = conf & cap; 480 481 /* 482 * Make sure we support all requested capabilities. 483 * NOTE: We assume that 'cap' represents a capability mask, 484 * not a discrete value. 485 */ 486 if ((hw & req_cap) != req_cap) { 487 wpa_printf(MSG_ERROR, 488 "Driver does not support configured VHT capability [%s]", 489 name); 490 return 0; 491 } 492 return 1; 493} 494 495 496static int ieee80211ac_cap_check_max(u32 hw, u32 conf, u32 mask, 497 unsigned int shift, 498 const char *name) 499{ 500 u32 hw_max = hw & mask; 501 u32 conf_val = conf & mask; 502 503 if (conf_val > hw_max) { 504 wpa_printf(MSG_ERROR, 505 "Configured VHT capability [%s] exceeds max value supported by the driver (%d > %d)", 506 name, conf_val >> shift, hw_max >> shift); 507 return 0; 508 } 509 return 1; 510} 511 512 513int ieee80211ac_cap_check(u32 hw, u32 conf) 514{ 515#define VHT_CAP_CHECK(cap) \ 516 do { \ 517 if (!_ieee80211ac_cap_check(hw, conf, cap, #cap)) \ 518 return 0; \ 519 } while (0) 520 521#define VHT_CAP_CHECK_MAX(cap) \ 522 do { \ 523 if (!ieee80211ac_cap_check_max(hw, conf, cap, cap ## _SHIFT, \ 524 #cap)) \ 525 return 0; \ 526 } while (0) 527 528 VHT_CAP_CHECK_MAX(VHT_CAP_MAX_MPDU_LENGTH_MASK); 529 VHT_CAP_CHECK(VHT_CAP_SUPP_CHAN_WIDTH_160MHZ); 530 VHT_CAP_CHECK(VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ); 531 VHT_CAP_CHECK(VHT_CAP_RXLDPC); 532 VHT_CAP_CHECK(VHT_CAP_SHORT_GI_80); 533 VHT_CAP_CHECK(VHT_CAP_SHORT_GI_160); 534 VHT_CAP_CHECK(VHT_CAP_TXSTBC); 535 VHT_CAP_CHECK_MAX(VHT_CAP_RXSTBC_MASK); 536 VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMER_CAPABLE); 537 VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMEE_CAPABLE); 538 VHT_CAP_CHECK_MAX(VHT_CAP_BEAMFORMEE_STS_MAX); 539 VHT_CAP_CHECK_MAX(VHT_CAP_SOUNDING_DIMENSION_MAX); 540 VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMER_CAPABLE); 541 VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMEE_CAPABLE); 542 VHT_CAP_CHECK(VHT_CAP_VHT_TXOP_PS); 543 VHT_CAP_CHECK(VHT_CAP_HTC_VHT); 544 VHT_CAP_CHECK_MAX(VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX); 545 VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB); 546 VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB); 547 VHT_CAP_CHECK(VHT_CAP_RX_ANTENNA_PATTERN); 548 VHT_CAP_CHECK(VHT_CAP_TX_ANTENNA_PATTERN); 549 550#undef VHT_CAP_CHECK 551#undef VHT_CAP_CHECK_MAX 552 553 return 1; 554} 555 556#endif /* CONFIG_IEEE80211AC */ 557