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 19 struct 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 43 struct hostapd_channel_data * 44 hw_mode_get_channel(struct hostapd_hw_modes *mode, int freq, int *chan) 45 { 46 int i; 47 48 for (i = 0; i < mode->num_channels; i++) { 49 struct hostapd_channel_data *ch = &mode->channels[i]; 50 51 if (ch->freq == freq) { 52 if (chan) 53 *chan = ch->chan; 54 return ch; 55 } 56 } 57 58 return NULL; 59 } 60 61 62 struct hostapd_channel_data * 63 hw_get_channel_freq(enum hostapd_hw_mode mode, int freq, int *chan, 64 struct hostapd_hw_modes *hw_features, int num_hw_features) 65 { 66 struct hostapd_channel_data *chan_data; 67 int i; 68 69 if (chan) 70 *chan = 0; 71 72 if (!hw_features) 73 return NULL; 74 75 for (i = 0; i < num_hw_features; i++) { 76 struct hostapd_hw_modes *curr_mode = &hw_features[i]; 77 78 if (curr_mode->mode != mode) 79 continue; 80 81 chan_data = hw_mode_get_channel(curr_mode, freq, chan); 82 if (chan_data) 83 return chan_data; 84 } 85 86 return NULL; 87 } 88 89 90 int hw_get_freq(struct hostapd_hw_modes *mode, int chan) 91 { 92 int freq; 93 94 hw_get_channel_chan(mode, chan, &freq); 95 96 return freq; 97 } 98 99 100 int hw_get_chan(enum hostapd_hw_mode mode, int freq, 101 struct hostapd_hw_modes *hw_features, int num_hw_features) 102 { 103 int chan; 104 105 hw_get_channel_freq(mode, freq, &chan, hw_features, num_hw_features); 106 107 return chan; 108 } 109 110 111 int allowed_ht40_channel_pair(enum hostapd_hw_mode mode, 112 struct hostapd_channel_data *p_chan, 113 struct hostapd_channel_data *s_chan) 114 { 115 int ok, first; 116 int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 140, 117 149, 157, 165, 173, 184, 192 }; 118 size_t k; 119 int ht40_plus, pri_chan, sec_chan; 120 121 if (!p_chan || !s_chan) 122 return 0; 123 pri_chan = p_chan->chan; 124 sec_chan = s_chan->chan; 125 126 ht40_plus = pri_chan < sec_chan; 127 128 if (pri_chan == sec_chan || !sec_chan) { 129 if (chan_pri_allowed(p_chan)) 130 return 1; /* HT40 not used */ 131 132 wpa_printf(MSG_ERROR, "Channel %d is not allowed as primary", 133 pri_chan); 134 return 0; 135 } 136 137 wpa_printf(MSG_DEBUG, 138 "HT40: control channel: %d (%d MHz), secondary channel: %d (%d MHz)", 139 pri_chan, p_chan->freq, sec_chan, s_chan->freq); 140 141 /* Verify that HT40 secondary channel is an allowed 20 MHz 142 * channel */ 143 if ((s_chan->flag & HOSTAPD_CHAN_DISABLED) || 144 (ht40_plus && !(p_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40P)) || 145 (!ht40_plus && !(p_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40M))) { 146 wpa_printf(MSG_ERROR, "HT40 secondary channel %d not allowed", 147 sec_chan); 148 return 0; 149 } 150 151 /* 152 * Verify that HT40 primary,secondary channel pair is allowed per 153 * IEEE 802.11n Annex J. This is only needed for 5 GHz band since 154 * 2.4 GHz rules allow all cases where the secondary channel fits into 155 * the list of allowed channels (already checked above). 156 */ 157 if (mode != HOSTAPD_MODE_IEEE80211A) 158 return 1; 159 160 first = pri_chan < sec_chan ? pri_chan : sec_chan; 161 162 ok = 0; 163 for (k = 0; k < ARRAY_SIZE(allowed); k++) { 164 if (first == allowed[k]) { 165 ok = 1; 166 break; 167 } 168 } 169 if (!ok) { 170 wpa_printf(MSG_ERROR, "HT40 channel pair (%d, %d) not allowed", 171 pri_chan, sec_chan); 172 return 0; 173 } 174 175 return 1; 176 } 177 178 179 void get_pri_sec_chan(struct wpa_scan_res *bss, int *pri_chan, int *sec_chan) 180 { 181 struct ieee80211_ht_operation *oper; 182 struct ieee802_11_elems elems; 183 184 *pri_chan = *sec_chan = 0; 185 186 ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0); 187 if (elems.ht_operation) { 188 oper = (struct ieee80211_ht_operation *) elems.ht_operation; 189 *pri_chan = oper->primary_chan; 190 if (oper->ht_param & HT_INFO_HT_PARAM_STA_CHNL_WIDTH) { 191 int sec = oper->ht_param & 192 HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK; 193 if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_ABOVE) 194 *sec_chan = *pri_chan + 4; 195 else if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_BELOW) 196 *sec_chan = *pri_chan - 4; 197 } 198 } 199 } 200 201 202 int check_40mhz_5g(struct wpa_scan_results *scan_res, 203 struct hostapd_channel_data *pri_chan, 204 struct hostapd_channel_data *sec_chan) 205 { 206 int pri_bss, sec_bss; 207 int bss_pri_chan, bss_sec_chan; 208 size_t i; 209 int match; 210 211 if (!scan_res || !pri_chan || !sec_chan || 212 pri_chan->freq == sec_chan->freq) 213 return 0; 214 215 /* 216 * Switch PRI/SEC channels if Beacons were detected on selected SEC 217 * channel, but not on selected PRI channel. 218 */ 219 pri_bss = sec_bss = 0; 220 for (i = 0; i < scan_res->num; i++) { 221 struct wpa_scan_res *bss = scan_res->res[i]; 222 if (bss->freq == pri_chan->freq) 223 pri_bss++; 224 else if (bss->freq == sec_chan->freq) 225 sec_bss++; 226 } 227 if (sec_bss && !pri_bss) { 228 wpa_printf(MSG_INFO, 229 "Switch own primary and secondary channel to get secondary channel with no Beacons from other BSSes"); 230 return 2; 231 } 232 233 /* 234 * Match PRI/SEC channel with any existing HT40 BSS on the same 235 * channels that we are about to use (if already mixed order in 236 * existing BSSes, use own preference). 237 */ 238 match = 0; 239 for (i = 0; i < scan_res->num; i++) { 240 struct wpa_scan_res *bss = scan_res->res[i]; 241 get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan); 242 if (pri_chan->chan == bss_pri_chan && 243 sec_chan->chan == bss_sec_chan) { 244 match = 1; 245 break; 246 } 247 } 248 if (!match) { 249 for (i = 0; i < scan_res->num; i++) { 250 struct wpa_scan_res *bss = scan_res->res[i]; 251 get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan); 252 if (pri_chan->chan == bss_sec_chan && 253 sec_chan->chan == bss_pri_chan) { 254 wpa_printf(MSG_INFO, "Switch own primary and " 255 "secondary channel due to BSS " 256 "overlap with " MACSTR, 257 MAC2STR(bss->bssid)); 258 return 2; 259 } 260 } 261 } 262 263 return 1; 264 } 265 266 267 static int check_20mhz_bss(struct wpa_scan_res *bss, int pri_freq, int start, 268 int end) 269 { 270 struct ieee802_11_elems elems; 271 struct ieee80211_ht_operation *oper; 272 273 if (bss->freq < start || bss->freq > end || bss->freq == pri_freq) 274 return 0; 275 276 ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0); 277 if (!elems.ht_capabilities) { 278 wpa_printf(MSG_DEBUG, "Found overlapping legacy BSS: " 279 MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq); 280 return 1; 281 } 282 283 if (elems.ht_operation) { 284 oper = (struct ieee80211_ht_operation *) elems.ht_operation; 285 if (oper->ht_param & HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK) 286 return 0; 287 288 wpa_printf(MSG_DEBUG, "Found overlapping 20 MHz HT BSS: " 289 MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq); 290 return 1; 291 } 292 return 0; 293 } 294 295 296 /* 297 * Returns: 298 * 0: no impact 299 * 1: overlapping BSS 300 * 2: overlapping BSS with 40 MHz intolerant advertisement 301 */ 302 int check_bss_coex_40mhz(struct wpa_scan_res *bss, int pri_freq, int sec_freq) 303 { 304 int affected_start, affected_end; 305 struct ieee802_11_elems elems; 306 int pri_chan, sec_chan; 307 int pri = bss->freq; 308 int sec = pri; 309 310 if (pri_freq == sec_freq) 311 return 1; 312 313 affected_start = (pri_freq + sec_freq) / 2 - 25; 314 affected_end = (pri_freq + sec_freq) / 2 + 25; 315 316 /* Check for overlapping 20 MHz BSS */ 317 if (check_20mhz_bss(bss, pri_freq, affected_start, affected_end)) { 318 wpa_printf(MSG_DEBUG, "Overlapping 20 MHz BSS is found"); 319 return 1; 320 } 321 322 get_pri_sec_chan(bss, &pri_chan, &sec_chan); 323 324 if (sec_chan) { 325 if (sec_chan < pri_chan) 326 sec = pri - 20; 327 else 328 sec = pri + 20; 329 } 330 331 if ((pri < affected_start || pri > affected_end) && 332 (sec < affected_start || sec > affected_end)) 333 return 0; /* not within affected channel range */ 334 335 wpa_printf(MSG_DEBUG, "Neighboring BSS: " MACSTR 336 " freq=%d pri=%d sec=%d", 337 MAC2STR(bss->bssid), bss->freq, pri_chan, sec_chan); 338 339 if (sec_chan) { 340 if (pri_freq != pri || sec_freq != sec) { 341 wpa_printf(MSG_DEBUG, 342 "40 MHz pri/sec mismatch with BSS " 343 MACSTR 344 " <%d,%d> (chan=%d%c) vs. <%d,%d>", 345 MAC2STR(bss->bssid), 346 pri, sec, pri_chan, 347 sec > pri ? '+' : '-', 348 pri_freq, sec_freq); 349 return 1; 350 } 351 } 352 353 ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0); 354 if (elems.ht_capabilities) { 355 struct ieee80211_ht_capabilities *ht_cap = 356 (struct ieee80211_ht_capabilities *) 357 elems.ht_capabilities; 358 359 if (le_to_host16(ht_cap->ht_capabilities_info) & 360 HT_CAP_INFO_40MHZ_INTOLERANT) { 361 wpa_printf(MSG_DEBUG, 362 "40 MHz Intolerant is set on channel %d in BSS " 363 MACSTR, pri, MAC2STR(bss->bssid)); 364 return 2; 365 } 366 } 367 368 return 0; 369 } 370 371 372 int check_40mhz_2g4(struct hostapd_hw_modes *mode, 373 struct wpa_scan_results *scan_res, int pri_chan, 374 int sec_chan) 375 { 376 int pri_freq, sec_freq; 377 size_t i; 378 379 if (!mode || !scan_res || !pri_chan || !sec_chan || 380 pri_chan == sec_chan) 381 return 0; 382 383 pri_freq = hw_get_freq(mode, pri_chan); 384 sec_freq = hw_get_freq(mode, sec_chan); 385 386 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz", 387 (pri_freq + sec_freq) / 2 - 25, 388 (pri_freq + sec_freq) / 2 + 25); 389 for (i = 0; i < scan_res->num; i++) { 390 if (check_bss_coex_40mhz(scan_res->res[i], pri_freq, sec_freq)) 391 return 0; 392 } 393 394 return 1; 395 } 396 397 398 int hostapd_set_freq_params(struct hostapd_freq_params *data, 399 enum hostapd_hw_mode mode, 400 int freq, int channel, int enable_edmg, 401 u8 edmg_channel, int ht_enabled, 402 int vht_enabled, int he_enabled, 403 int sec_channel_offset, 404 int oper_chwidth, int center_segment0, 405 int center_segment1, u32 vht_caps, 406 struct he_capabilities *he_cap) 407 { 408 if (!he_cap || !he_cap->he_supported) 409 he_enabled = 0; 410 os_memset(data, 0, sizeof(*data)); 411 data->mode = mode; 412 data->freq = freq; 413 data->channel = channel; 414 data->ht_enabled = ht_enabled; 415 data->vht_enabled = vht_enabled; 416 data->he_enabled = he_enabled; 417 data->sec_channel_offset = sec_channel_offset; 418 data->center_freq1 = freq + sec_channel_offset * 10; 419 data->center_freq2 = 0; 420 if (oper_chwidth == CHANWIDTH_80MHZ) 421 data->bandwidth = 80; 422 else if (oper_chwidth == CHANWIDTH_160MHZ || 423 oper_chwidth == CHANWIDTH_80P80MHZ) 424 data->bandwidth = 160; 425 else if (sec_channel_offset) 426 data->bandwidth = 40; 427 else 428 data->bandwidth = 20; 429 430 431 hostapd_encode_edmg_chan(enable_edmg, edmg_channel, channel, 432 &data->edmg); 433 434 if (is_6ghz_freq(freq)) { 435 if (!data->he_enabled) { 436 wpa_printf(MSG_ERROR, 437 "Can't set 6 GHz mode - HE isn't enabled"); 438 return -1; 439 } 440 441 if (center_idx_to_bw_6ghz(channel) < 0) { 442 wpa_printf(MSG_ERROR, 443 "Invalid control channel for 6 GHz band"); 444 return -1; 445 } 446 447 if (!center_segment0) { 448 if (center_segment1) { 449 wpa_printf(MSG_ERROR, 450 "Segment 0 center frequency isn't set"); 451 return -1; 452 } 453 if (!sec_channel_offset) 454 data->center_freq1 = data->freq; 455 } else { 456 int freq1, freq2 = 0; 457 int bw = center_idx_to_bw_6ghz(center_segment0); 458 459 if (bw < 0) { 460 wpa_printf(MSG_ERROR, 461 "Invalid center frequency index for 6 GHz"); 462 return -1; 463 } 464 465 freq1 = ieee80211_chan_to_freq(NULL, 131, 466 center_segment0); 467 if (freq1 < 0) { 468 wpa_printf(MSG_ERROR, 469 "Invalid segment 0 center frequency for 6 GHz"); 470 return -1; 471 } 472 473 if (center_segment1) { 474 if (center_idx_to_bw_6ghz(center_segment1) != 2 || 475 bw != 2) { 476 wpa_printf(MSG_ERROR, 477 "6 GHz 80+80 MHz configuration doesn't use valid 80 MHz channels"); 478 return -1; 479 } 480 481 freq2 = ieee80211_chan_to_freq(NULL, 131, 482 center_segment1); 483 if (freq2 < 0) { 484 wpa_printf(MSG_ERROR, 485 "Invalid segment 1 center frequency for UHB"); 486 return -1; 487 } 488 } 489 490 data->bandwidth = (1 << (u8) bw) * 20; 491 data->center_freq1 = freq1; 492 data->center_freq2 = freq2; 493 } 494 data->ht_enabled = 0; 495 data->vht_enabled = 0; 496 497 return 0; 498 } 499 500 if (data->he_enabled) switch (oper_chwidth) { 501 case CHANWIDTH_USE_HT: 502 if (sec_channel_offset == 0) 503 break; 504 505 if (mode == HOSTAPD_MODE_IEEE80211G) { 506 if (!(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & 507 HE_PHYCAP_CHANNEL_WIDTH_SET_40MHZ_IN_2G)) { 508 wpa_printf(MSG_ERROR, 509 "40 MHz channel width is not supported in 2.4 GHz"); 510 return -1; 511 } 512 break; 513 } 514 /* fall through */ 515 case CHANWIDTH_80MHZ: 516 if (mode == HOSTAPD_MODE_IEEE80211A) { 517 if (!(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & 518 HE_PHYCAP_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G)) { 519 wpa_printf(MSG_ERROR, 520 "40/80 MHz channel width is not supported in 5/6 GHz"); 521 return -1; 522 } 523 } 524 break; 525 case CHANWIDTH_80P80MHZ: 526 if (!(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & 527 HE_PHYCAP_CHANNEL_WIDTH_SET_80PLUS80MHZ_IN_5G)) { 528 wpa_printf(MSG_ERROR, 529 "80+80 MHz channel width is not supported in 5/6 GHz"); 530 return -1; 531 } 532 break; 533 case CHANWIDTH_160MHZ: 534 if (!(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & 535 HE_PHYCAP_CHANNEL_WIDTH_SET_160MHZ_IN_5G)) { 536 wpa_printf(MSG_ERROR, 537 "160 MHz channel width is not supported in 5 / 6GHz"); 538 return -1; 539 } 540 break; 541 } else if (data->vht_enabled) switch (oper_chwidth) { 542 case CHANWIDTH_USE_HT: 543 break; 544 case CHANWIDTH_80P80MHZ: 545 if (!(vht_caps & VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) { 546 wpa_printf(MSG_ERROR, 547 "80+80 channel width is not supported!"); 548 return -1; 549 } 550 /* fall through */ 551 case CHANWIDTH_80MHZ: 552 break; 553 case CHANWIDTH_160MHZ: 554 if (!(vht_caps & (VHT_CAP_SUPP_CHAN_WIDTH_160MHZ | 555 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))) { 556 wpa_printf(MSG_ERROR, 557 "160 MHz channel width is not supported!"); 558 return -1; 559 } 560 break; 561 } 562 563 if (data->he_enabled || data->vht_enabled) switch (oper_chwidth) { 564 case CHANWIDTH_USE_HT: 565 if (center_segment1 || 566 (center_segment0 != 0 && 567 5000 + center_segment0 * 5 != data->center_freq1 && 568 2407 + center_segment0 * 5 != data->center_freq1)) { 569 wpa_printf(MSG_ERROR, 570 "20/40 MHz: center segment 0 (=%d) and center freq 1 (=%d) not in sync", 571 center_segment0, data->center_freq1); 572 return -1; 573 } 574 break; 575 case CHANWIDTH_80P80MHZ: 576 if (center_segment1 == center_segment0 + 4 || 577 center_segment1 == center_segment0 - 4) { 578 wpa_printf(MSG_ERROR, 579 "80+80 MHz: center segment 1 only 20 MHz apart"); 580 return -1; 581 } 582 data->center_freq2 = 5000 + center_segment1 * 5; 583 /* fall through */ 584 case CHANWIDTH_80MHZ: 585 data->bandwidth = 80; 586 if (!sec_channel_offset) { 587 wpa_printf(MSG_ERROR, 588 "80/80+80 MHz: no second channel offset"); 589 return -1; 590 } 591 if (oper_chwidth == CHANWIDTH_80MHZ && center_segment1) { 592 wpa_printf(MSG_ERROR, 593 "80 MHz: center segment 1 configured"); 594 return -1; 595 } 596 if (oper_chwidth == CHANWIDTH_80P80MHZ && !center_segment1) { 597 wpa_printf(MSG_ERROR, 598 "80+80 MHz: center segment 1 not configured"); 599 return -1; 600 } 601 if (!center_segment0) { 602 if (channel <= 48) 603 center_segment0 = 42; 604 else if (channel <= 64) 605 center_segment0 = 58; 606 else if (channel <= 112) 607 center_segment0 = 106; 608 else if (channel <= 128) 609 center_segment0 = 122; 610 else if (channel <= 144) 611 center_segment0 = 138; 612 else if (channel <= 161) 613 center_segment0 = 155; 614 else if (channel <= 177) 615 center_segment0 = 171; 616 data->center_freq1 = 5000 + center_segment0 * 5; 617 } else { 618 /* 619 * Note: HT/VHT config and params are coupled. Check if 620 * HT40 channel band is in VHT80 Pri channel band 621 * configuration. 622 */ 623 if (center_segment0 == channel + 6 || 624 center_segment0 == channel + 2 || 625 center_segment0 == channel - 2 || 626 center_segment0 == channel - 6) 627 data->center_freq1 = 5000 + center_segment0 * 5; 628 else { 629 wpa_printf(MSG_ERROR, 630 "Wrong coupling between HT and VHT/HE channel setting"); 631 return -1; 632 } 633 } 634 break; 635 case CHANWIDTH_160MHZ: 636 data->bandwidth = 160; 637 if (center_segment1) { 638 wpa_printf(MSG_ERROR, 639 "160 MHz: center segment 1 should not be set"); 640 return -1; 641 } 642 if (!sec_channel_offset) { 643 wpa_printf(MSG_ERROR, 644 "160 MHz: second channel offset not set"); 645 return -1; 646 } 647 /* 648 * Note: HT/VHT config and params are coupled. Check if 649 * HT40 channel band is in VHT160 channel band configuration. 650 */ 651 if (center_segment0 == channel + 14 || 652 center_segment0 == channel + 10 || 653 center_segment0 == channel + 6 || 654 center_segment0 == channel + 2 || 655 center_segment0 == channel - 2 || 656 center_segment0 == channel - 6 || 657 center_segment0 == channel - 10 || 658 center_segment0 == channel - 14) 659 data->center_freq1 = 5000 + center_segment0 * 5; 660 else { 661 wpa_printf(MSG_ERROR, 662 "160 MHz: HT40 channel band is not in 160 MHz band"); 663 return -1; 664 } 665 break; 666 } 667 668 return 0; 669 } 670 671 672 void set_disable_ht40(struct ieee80211_ht_capabilities *htcaps, 673 int disabled) 674 { 675 /* Masking these out disables HT40 */ 676 le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET | 677 HT_CAP_INFO_SHORT_GI40MHZ); 678 679 if (disabled) 680 htcaps->ht_capabilities_info &= ~msk; 681 else 682 htcaps->ht_capabilities_info |= msk; 683 } 684 685 686 #ifdef CONFIG_IEEE80211AC 687 688 static int _ieee80211ac_cap_check(u32 hw, u32 conf, u32 cap, 689 const char *name) 690 { 691 u32 req_cap = conf & cap; 692 693 /* 694 * Make sure we support all requested capabilities. 695 * NOTE: We assume that 'cap' represents a capability mask, 696 * not a discrete value. 697 */ 698 if ((hw & req_cap) != req_cap) { 699 wpa_printf(MSG_ERROR, 700 "Driver does not support configured VHT capability [%s]", 701 name); 702 return 0; 703 } 704 return 1; 705 } 706 707 708 static int ieee80211ac_cap_check_max(u32 hw, u32 conf, u32 mask, 709 unsigned int shift, 710 const char *name) 711 { 712 u32 hw_max = hw & mask; 713 u32 conf_val = conf & mask; 714 715 if (conf_val > hw_max) { 716 wpa_printf(MSG_ERROR, 717 "Configured VHT capability [%s] exceeds max value supported by the driver (%d > %d)", 718 name, conf_val >> shift, hw_max >> shift); 719 return 0; 720 } 721 return 1; 722 } 723 724 725 int ieee80211ac_cap_check(u32 hw, u32 conf) 726 { 727 #define VHT_CAP_CHECK(cap) \ 728 do { \ 729 if (!_ieee80211ac_cap_check(hw, conf, cap, #cap)) \ 730 return 0; \ 731 } while (0) 732 733 #define VHT_CAP_CHECK_MAX(cap) \ 734 do { \ 735 if (!ieee80211ac_cap_check_max(hw, conf, cap, cap ## _SHIFT, \ 736 #cap)) \ 737 return 0; \ 738 } while (0) 739 740 VHT_CAP_CHECK_MAX(VHT_CAP_MAX_MPDU_LENGTH_MASK); 741 VHT_CAP_CHECK_MAX(VHT_CAP_SUPP_CHAN_WIDTH_MASK); 742 VHT_CAP_CHECK(VHT_CAP_RXLDPC); 743 VHT_CAP_CHECK(VHT_CAP_SHORT_GI_80); 744 VHT_CAP_CHECK(VHT_CAP_SHORT_GI_160); 745 VHT_CAP_CHECK(VHT_CAP_TXSTBC); 746 VHT_CAP_CHECK_MAX(VHT_CAP_RXSTBC_MASK); 747 VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMER_CAPABLE); 748 VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMEE_CAPABLE); 749 VHT_CAP_CHECK_MAX(VHT_CAP_BEAMFORMEE_STS_MAX); 750 VHT_CAP_CHECK_MAX(VHT_CAP_SOUNDING_DIMENSION_MAX); 751 VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMER_CAPABLE); 752 VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMEE_CAPABLE); 753 VHT_CAP_CHECK(VHT_CAP_VHT_TXOP_PS); 754 VHT_CAP_CHECK(VHT_CAP_HTC_VHT); 755 VHT_CAP_CHECK_MAX(VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX); 756 VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB); 757 VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB); 758 VHT_CAP_CHECK(VHT_CAP_RX_ANTENNA_PATTERN); 759 VHT_CAP_CHECK(VHT_CAP_TX_ANTENNA_PATTERN); 760 761 #undef VHT_CAP_CHECK 762 #undef VHT_CAP_CHECK_MAX 763 764 return 1; 765 } 766 767 #endif /* CONFIG_IEEE80211AC */ 768 769 770 u32 num_chan_to_bw(int num_chans) 771 { 772 switch (num_chans) { 773 case 2: 774 case 4: 775 case 8: 776 return num_chans * 20; 777 default: 778 return 20; 779 } 780 } 781 782 783 /* check if BW is applicable for channel */ 784 int chan_bw_allowed(const struct hostapd_channel_data *chan, u32 bw, 785 int ht40_plus, int pri) 786 { 787 u32 bw_mask; 788 789 switch (bw) { 790 case 20: 791 bw_mask = HOSTAPD_CHAN_WIDTH_20; 792 break; 793 case 40: 794 /* HT 40 MHz support declared only for primary channel, 795 * just skip 40 MHz secondary checking */ 796 if (pri && ht40_plus) 797 bw_mask = HOSTAPD_CHAN_WIDTH_40P; 798 else if (pri && !ht40_plus) 799 bw_mask = HOSTAPD_CHAN_WIDTH_40M; 800 else 801 bw_mask = 0; 802 break; 803 case 80: 804 bw_mask = HOSTAPD_CHAN_WIDTH_80; 805 break; 806 case 160: 807 bw_mask = HOSTAPD_CHAN_WIDTH_160; 808 break; 809 default: 810 bw_mask = 0; 811 break; 812 } 813 814 return (chan->allowed_bw & bw_mask) == bw_mask; 815 } 816 817 818 /* check if channel is allowed to be used as primary */ 819 int chan_pri_allowed(const struct hostapd_channel_data *chan) 820 { 821 return !(chan->flag & HOSTAPD_CHAN_DISABLED) && 822 (chan->allowed_bw & HOSTAPD_CHAN_WIDTH_20); 823 } 824