1 /* 2 * hostapd / Hardware feature query and different modes 3 * Copyright 2002-2003, Instant802 Networks, Inc. 4 * Copyright 2005-2006, Devicescape Software, Inc. 5 * Copyright (c) 2008-2012, Jouni Malinen <j@w1.fi> 6 * 7 * This software may be distributed under the terms of the BSD license. 8 * See README for more details. 9 */ 10 11 #include "utils/includes.h" 12 13 #include "utils/common.h" 14 #include "utils/eloop.h" 15 #include "common/ieee802_11_defs.h" 16 #include "common/ieee802_11_common.h" 17 #include "common/wpa_ctrl.h" 18 #include "hostapd.h" 19 #include "ap_config.h" 20 #include "ap_drv_ops.h" 21 #include "acs.h" 22 #include "hw_features.h" 23 24 25 void hostapd_free_hw_features(struct hostapd_hw_modes *hw_features, 26 size_t num_hw_features) 27 { 28 size_t i; 29 30 if (hw_features == NULL) 31 return; 32 33 for (i = 0; i < num_hw_features; i++) { 34 os_free(hw_features[i].channels); 35 os_free(hw_features[i].rates); 36 } 37 38 os_free(hw_features); 39 } 40 41 42 #ifndef CONFIG_NO_STDOUT_DEBUG 43 static char * dfs_info(struct hostapd_channel_data *chan) 44 { 45 static char info[256]; 46 char *state; 47 48 switch (chan->flag & HOSTAPD_CHAN_DFS_MASK) { 49 case HOSTAPD_CHAN_DFS_UNKNOWN: 50 state = "unknown"; 51 break; 52 case HOSTAPD_CHAN_DFS_USABLE: 53 state = "usable"; 54 break; 55 case HOSTAPD_CHAN_DFS_UNAVAILABLE: 56 state = "unavailable"; 57 break; 58 case HOSTAPD_CHAN_DFS_AVAILABLE: 59 state = "available"; 60 break; 61 default: 62 return ""; 63 } 64 os_snprintf(info, sizeof(info), " (DFS state = %s)", state); 65 info[sizeof(info) - 1] = '\0'; 66 67 return info; 68 } 69 #endif /* CONFIG_NO_STDOUT_DEBUG */ 70 71 72 int hostapd_get_hw_features(struct hostapd_iface *iface) 73 { 74 struct hostapd_data *hapd = iface->bss[0]; 75 int ret = 0, i, j; 76 u16 num_modes, flags; 77 struct hostapd_hw_modes *modes; 78 79 if (hostapd_drv_none(hapd)) 80 return -1; 81 modes = hostapd_get_hw_feature_data(hapd, &num_modes, &flags); 82 if (modes == NULL) { 83 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 84 HOSTAPD_LEVEL_DEBUG, 85 "Fetching hardware channel/rate support not " 86 "supported."); 87 return -1; 88 } 89 90 iface->hw_flags = flags; 91 92 hostapd_free_hw_features(iface->hw_features, iface->num_hw_features); 93 iface->hw_features = modes; 94 iface->num_hw_features = num_modes; 95 96 for (i = 0; i < num_modes; i++) { 97 struct hostapd_hw_modes *feature = &modes[i]; 98 int dfs_enabled = hapd->iconf->ieee80211h && 99 (iface->drv_flags & WPA_DRIVER_FLAGS_RADAR); 100 101 /* set flag for channels we can use in current regulatory 102 * domain */ 103 for (j = 0; j < feature->num_channels; j++) { 104 int dfs = 0; 105 106 /* 107 * Disable all channels that are marked not to allow 108 * IBSS operation or active scanning. 109 * Use radar channels only if the driver supports DFS. 110 */ 111 if ((feature->channels[j].flag & 112 HOSTAPD_CHAN_RADAR) && dfs_enabled) { 113 dfs = 1; 114 } else if (feature->channels[j].flag & 115 (HOSTAPD_CHAN_NO_IBSS | 116 HOSTAPD_CHAN_PASSIVE_SCAN | 117 HOSTAPD_CHAN_RADAR)) { 118 feature->channels[j].flag |= 119 HOSTAPD_CHAN_DISABLED; 120 } 121 122 if (feature->channels[j].flag & HOSTAPD_CHAN_DISABLED) 123 continue; 124 125 wpa_printf(MSG_MSGDUMP, "Allowed channel: mode=%d " 126 "chan=%d freq=%d MHz max_tx_power=%d dBm%s", 127 feature->mode, 128 feature->channels[j].chan, 129 feature->channels[j].freq, 130 feature->channels[j].max_tx_power, 131 dfs ? dfs_info(&feature->channels[j]) : ""); 132 } 133 } 134 135 return ret; 136 } 137 138 139 int hostapd_prepare_rates(struct hostapd_iface *iface, 140 struct hostapd_hw_modes *mode) 141 { 142 int i, num_basic_rates = 0; 143 int basic_rates_a[] = { 60, 120, 240, -1 }; 144 int basic_rates_b[] = { 10, 20, -1 }; 145 int basic_rates_g[] = { 10, 20, 55, 110, -1 }; 146 int *basic_rates; 147 148 if (iface->conf->basic_rates) 149 basic_rates = iface->conf->basic_rates; 150 else switch (mode->mode) { 151 case HOSTAPD_MODE_IEEE80211A: 152 basic_rates = basic_rates_a; 153 break; 154 case HOSTAPD_MODE_IEEE80211B: 155 basic_rates = basic_rates_b; 156 break; 157 case HOSTAPD_MODE_IEEE80211G: 158 basic_rates = basic_rates_g; 159 break; 160 case HOSTAPD_MODE_IEEE80211AD: 161 return 0; /* No basic rates for 11ad */ 162 default: 163 return -1; 164 } 165 166 i = 0; 167 while (basic_rates[i] >= 0) 168 i++; 169 if (i) 170 i++; /* -1 termination */ 171 os_free(iface->basic_rates); 172 iface->basic_rates = os_malloc(i * sizeof(int)); 173 if (iface->basic_rates) 174 os_memcpy(iface->basic_rates, basic_rates, i * sizeof(int)); 175 176 os_free(iface->current_rates); 177 iface->num_rates = 0; 178 179 iface->current_rates = 180 os_calloc(mode->num_rates, sizeof(struct hostapd_rate_data)); 181 if (!iface->current_rates) { 182 wpa_printf(MSG_ERROR, "Failed to allocate memory for rate " 183 "table."); 184 return -1; 185 } 186 187 for (i = 0; i < mode->num_rates; i++) { 188 struct hostapd_rate_data *rate; 189 190 if (iface->conf->supported_rates && 191 !hostapd_rate_found(iface->conf->supported_rates, 192 mode->rates[i])) 193 continue; 194 195 rate = &iface->current_rates[iface->num_rates]; 196 rate->rate = mode->rates[i]; 197 if (hostapd_rate_found(basic_rates, rate->rate)) { 198 rate->flags |= HOSTAPD_RATE_BASIC; 199 num_basic_rates++; 200 } 201 wpa_printf(MSG_DEBUG, "RATE[%d] rate=%d flags=0x%x", 202 iface->num_rates, rate->rate, rate->flags); 203 iface->num_rates++; 204 } 205 206 if ((iface->num_rates == 0 || num_basic_rates == 0) && 207 (!iface->conf->ieee80211n || !iface->conf->require_ht)) { 208 wpa_printf(MSG_ERROR, "No rates remaining in supported/basic " 209 "rate sets (%d,%d).", 210 iface->num_rates, num_basic_rates); 211 return -1; 212 } 213 214 return 0; 215 } 216 217 218 #ifdef CONFIG_IEEE80211N 219 static int ieee80211n_allowed_ht40_channel_pair(struct hostapd_iface *iface) 220 { 221 int sec_chan, ok, j, first; 222 int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157, 223 184, 192 }; 224 size_t k; 225 226 if (!iface->conf->secondary_channel) 227 return 1; /* HT40 not used */ 228 229 sec_chan = iface->conf->channel + iface->conf->secondary_channel * 4; 230 wpa_printf(MSG_DEBUG, "HT40: control channel: %d " 231 "secondary channel: %d", 232 iface->conf->channel, sec_chan); 233 234 /* Verify that HT40 secondary channel is an allowed 20 MHz 235 * channel */ 236 ok = 0; 237 for (j = 0; j < iface->current_mode->num_channels; j++) { 238 struct hostapd_channel_data *chan = 239 &iface->current_mode->channels[j]; 240 if (!(chan->flag & HOSTAPD_CHAN_DISABLED) && 241 chan->chan == sec_chan) { 242 ok = 1; 243 break; 244 } 245 } 246 if (!ok) { 247 wpa_printf(MSG_ERROR, "HT40 secondary channel %d not allowed", 248 sec_chan); 249 return 0; 250 } 251 252 /* 253 * Verify that HT40 primary,secondary channel pair is allowed per 254 * IEEE 802.11n Annex J. This is only needed for 5 GHz band since 255 * 2.4 GHz rules allow all cases where the secondary channel fits into 256 * the list of allowed channels (already checked above). 257 */ 258 if (iface->current_mode->mode != HOSTAPD_MODE_IEEE80211A) 259 return 1; 260 261 if (iface->conf->secondary_channel > 0) 262 first = iface->conf->channel; 263 else 264 first = sec_chan; 265 266 ok = 0; 267 for (k = 0; k < ARRAY_SIZE(allowed); k++) { 268 if (first == allowed[k]) { 269 ok = 1; 270 break; 271 } 272 } 273 if (!ok) { 274 wpa_printf(MSG_ERROR, "HT40 channel pair (%d, %d) not allowed", 275 iface->conf->channel, 276 iface->conf->secondary_channel); 277 return 0; 278 } 279 280 return 1; 281 } 282 283 284 static void ieee80211n_switch_pri_sec(struct hostapd_iface *iface) 285 { 286 if (iface->conf->secondary_channel > 0) { 287 iface->conf->channel += 4; 288 iface->conf->secondary_channel = -1; 289 } else { 290 iface->conf->channel -= 4; 291 iface->conf->secondary_channel = 1; 292 } 293 } 294 295 296 static void ieee80211n_get_pri_sec_chan(struct wpa_scan_res *bss, 297 int *pri_chan, int *sec_chan) 298 { 299 struct ieee80211_ht_operation *oper; 300 struct ieee802_11_elems elems; 301 302 *pri_chan = *sec_chan = 0; 303 304 ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0); 305 if (elems.ht_operation && 306 elems.ht_operation_len >= sizeof(*oper)) { 307 oper = (struct ieee80211_ht_operation *) elems.ht_operation; 308 *pri_chan = oper->control_chan; 309 if (oper->ht_param & HT_INFO_HT_PARAM_REC_TRANS_CHNL_WIDTH) { 310 int sec = oper->ht_param & 311 HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK; 312 if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_ABOVE) 313 *sec_chan = *pri_chan + 4; 314 else if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_BELOW) 315 *sec_chan = *pri_chan - 4; 316 } 317 } 318 } 319 320 321 static int ieee80211n_check_40mhz_5g(struct hostapd_iface *iface, 322 struct wpa_scan_results *scan_res) 323 { 324 int pri_chan, sec_chan, pri_freq, sec_freq, pri_bss, sec_bss; 325 int bss_pri_chan, bss_sec_chan; 326 size_t i; 327 int match; 328 329 pri_chan = iface->conf->channel; 330 sec_chan = iface->conf->secondary_channel * 4; 331 pri_freq = hostapd_hw_get_freq(iface->bss[0], pri_chan); 332 if (iface->conf->secondary_channel > 0) 333 sec_freq = pri_freq + 20; 334 else 335 sec_freq = pri_freq - 20; 336 337 /* 338 * Switch PRI/SEC channels if Beacons were detected on selected SEC 339 * channel, but not on selected PRI channel. 340 */ 341 pri_bss = sec_bss = 0; 342 for (i = 0; i < scan_res->num; i++) { 343 struct wpa_scan_res *bss = scan_res->res[i]; 344 if (bss->freq == pri_freq) 345 pri_bss++; 346 else if (bss->freq == sec_freq) 347 sec_bss++; 348 } 349 if (sec_bss && !pri_bss) { 350 wpa_printf(MSG_INFO, "Switch own primary and secondary " 351 "channel to get secondary channel with no Beacons " 352 "from other BSSes"); 353 ieee80211n_switch_pri_sec(iface); 354 } 355 356 /* 357 * Match PRI/SEC channel with any existing HT40 BSS on the same 358 * channels that we are about to use (if already mixed order in 359 * existing BSSes, use own preference). 360 */ 361 match = 0; 362 for (i = 0; i < scan_res->num; i++) { 363 struct wpa_scan_res *bss = scan_res->res[i]; 364 ieee80211n_get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan); 365 if (pri_chan == bss_pri_chan && 366 sec_chan == bss_sec_chan) { 367 match = 1; 368 break; 369 } 370 } 371 if (!match) { 372 for (i = 0; i < scan_res->num; i++) { 373 struct wpa_scan_res *bss = scan_res->res[i]; 374 ieee80211n_get_pri_sec_chan(bss, &bss_pri_chan, 375 &bss_sec_chan); 376 if (pri_chan == bss_sec_chan && 377 sec_chan == bss_pri_chan) { 378 wpa_printf(MSG_INFO, "Switch own primary and " 379 "secondary channel due to BSS " 380 "overlap with " MACSTR, 381 MAC2STR(bss->bssid)); 382 ieee80211n_switch_pri_sec(iface); 383 break; 384 } 385 } 386 } 387 388 return 1; 389 } 390 391 392 static int ieee80211n_check_40mhz_2g4(struct hostapd_iface *iface, 393 struct wpa_scan_results *scan_res) 394 { 395 int pri_freq, sec_freq; 396 int affected_start, affected_end; 397 size_t i; 398 399 pri_freq = hostapd_hw_get_freq(iface->bss[0], iface->conf->channel); 400 if (iface->conf->secondary_channel > 0) 401 sec_freq = pri_freq + 20; 402 else 403 sec_freq = pri_freq - 20; 404 affected_start = (pri_freq + sec_freq) / 2 - 25; 405 affected_end = (pri_freq + sec_freq) / 2 + 25; 406 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz", 407 affected_start, affected_end); 408 for (i = 0; i < scan_res->num; i++) { 409 struct wpa_scan_res *bss = scan_res->res[i]; 410 int pri = bss->freq; 411 int sec = pri; 412 int sec_chan, pri_chan; 413 414 ieee80211n_get_pri_sec_chan(bss, &pri_chan, &sec_chan); 415 416 if (sec_chan) { 417 if (sec_chan < pri_chan) 418 sec = pri - 20; 419 else 420 sec = pri + 20; 421 } 422 423 if ((pri < affected_start || pri > affected_end) && 424 (sec < affected_start || sec > affected_end)) 425 continue; /* not within affected channel range */ 426 427 wpa_printf(MSG_DEBUG, "Neighboring BSS: " MACSTR 428 " freq=%d pri=%d sec=%d", 429 MAC2STR(bss->bssid), bss->freq, pri_chan, sec_chan); 430 431 if (sec_chan) { 432 if (pri_freq != pri || sec_freq != sec) { 433 wpa_printf(MSG_DEBUG, "40 MHz pri/sec " 434 "mismatch with BSS " MACSTR 435 " <%d,%d> (chan=%d%c) vs. <%d,%d>", 436 MAC2STR(bss->bssid), 437 pri, sec, pri_chan, 438 sec > pri ? '+' : '-', 439 pri_freq, sec_freq); 440 return 0; 441 } 442 } 443 444 /* TODO: 40 MHz intolerant */ 445 } 446 447 return 1; 448 } 449 450 451 static void ieee80211n_check_scan(struct hostapd_iface *iface) 452 { 453 struct wpa_scan_results *scan_res; 454 int oper40; 455 int res; 456 457 /* Check list of neighboring BSSes (from scan) to see whether 40 MHz is 458 * allowed per IEEE Std 802.11-2012, 10.15.3.2 */ 459 460 iface->scan_cb = NULL; 461 462 scan_res = hostapd_driver_get_scan_results(iface->bss[0]); 463 if (scan_res == NULL) { 464 hostapd_setup_interface_complete(iface, 1); 465 return; 466 } 467 468 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A) 469 oper40 = ieee80211n_check_40mhz_5g(iface, scan_res); 470 else 471 oper40 = ieee80211n_check_40mhz_2g4(iface, scan_res); 472 wpa_scan_results_free(scan_res); 473 474 if (!oper40) { 475 wpa_printf(MSG_INFO, "20/40 MHz operation not permitted on " 476 "channel pri=%d sec=%d based on overlapping BSSes", 477 iface->conf->channel, 478 iface->conf->channel + 479 iface->conf->secondary_channel * 4); 480 iface->conf->secondary_channel = 0; 481 } 482 483 res = ieee80211n_allowed_ht40_channel_pair(iface); 484 hostapd_setup_interface_complete(iface, !res); 485 } 486 487 488 static void ieee80211n_scan_channels_2g4(struct hostapd_iface *iface, 489 struct wpa_driver_scan_params *params) 490 { 491 /* Scan only the affected frequency range */ 492 int pri_freq, sec_freq; 493 int affected_start, affected_end; 494 int i, pos; 495 struct hostapd_hw_modes *mode; 496 497 if (iface->current_mode == NULL) 498 return; 499 500 pri_freq = hostapd_hw_get_freq(iface->bss[0], iface->conf->channel); 501 if (iface->conf->secondary_channel > 0) 502 sec_freq = pri_freq + 20; 503 else 504 sec_freq = pri_freq - 20; 505 affected_start = (pri_freq + sec_freq) / 2 - 25; 506 affected_end = (pri_freq + sec_freq) / 2 + 25; 507 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz", 508 affected_start, affected_end); 509 510 mode = iface->current_mode; 511 params->freqs = os_calloc(mode->num_channels + 1, sizeof(int)); 512 if (params->freqs == NULL) 513 return; 514 pos = 0; 515 516 for (i = 0; i < mode->num_channels; i++) { 517 struct hostapd_channel_data *chan = &mode->channels[i]; 518 if (chan->flag & HOSTAPD_CHAN_DISABLED) 519 continue; 520 if (chan->freq < affected_start || 521 chan->freq > affected_end) 522 continue; 523 params->freqs[pos++] = chan->freq; 524 } 525 } 526 527 528 static void ieee80211n_scan_channels_5g(struct hostapd_iface *iface, 529 struct wpa_driver_scan_params *params) 530 { 531 /* Scan only the affected frequency range */ 532 int pri_freq; 533 int affected_start, affected_end; 534 int i, pos; 535 struct hostapd_hw_modes *mode; 536 537 if (iface->current_mode == NULL) 538 return; 539 540 pri_freq = hostapd_hw_get_freq(iface->bss[0], iface->conf->channel); 541 if (iface->conf->secondary_channel > 0) { 542 affected_start = pri_freq - 10; 543 affected_end = pri_freq + 30; 544 } else { 545 affected_start = pri_freq - 30; 546 affected_end = pri_freq + 10; 547 } 548 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz", 549 affected_start, affected_end); 550 551 mode = iface->current_mode; 552 params->freqs = os_calloc(mode->num_channels + 1, sizeof(int)); 553 if (params->freqs == NULL) 554 return; 555 pos = 0; 556 557 for (i = 0; i < mode->num_channels; i++) { 558 struct hostapd_channel_data *chan = &mode->channels[i]; 559 if (chan->flag & HOSTAPD_CHAN_DISABLED) 560 continue; 561 if (chan->freq < affected_start || 562 chan->freq > affected_end) 563 continue; 564 params->freqs[pos++] = chan->freq; 565 } 566 } 567 568 569 static int ieee80211n_check_40mhz(struct hostapd_iface *iface) 570 { 571 struct wpa_driver_scan_params params; 572 573 if (!iface->conf->secondary_channel) 574 return 0; /* HT40 not used */ 575 576 hostapd_set_state(iface, HAPD_IFACE_HT_SCAN); 577 wpa_printf(MSG_DEBUG, "Scan for neighboring BSSes prior to enabling " 578 "40 MHz channel"); 579 os_memset(¶ms, 0, sizeof(params)); 580 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G) 581 ieee80211n_scan_channels_2g4(iface, ¶ms); 582 else 583 ieee80211n_scan_channels_5g(iface, ¶ms); 584 if (hostapd_driver_scan(iface->bss[0], ¶ms) < 0) { 585 wpa_printf(MSG_ERROR, "Failed to request a scan of " 586 "neighboring BSSes"); 587 os_free(params.freqs); 588 return -1; 589 } 590 os_free(params.freqs); 591 592 iface->scan_cb = ieee80211n_check_scan; 593 return 1; 594 } 595 596 597 static int ieee80211n_supported_ht_capab(struct hostapd_iface *iface) 598 { 599 u16 hw = iface->current_mode->ht_capab; 600 u16 conf = iface->conf->ht_capab; 601 602 if ((conf & HT_CAP_INFO_LDPC_CODING_CAP) && 603 !(hw & HT_CAP_INFO_LDPC_CODING_CAP)) { 604 wpa_printf(MSG_ERROR, "Driver does not support configured " 605 "HT capability [LDPC]"); 606 return 0; 607 } 608 609 if ((conf & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET) && 610 !(hw & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) { 611 wpa_printf(MSG_ERROR, "Driver does not support configured " 612 "HT capability [HT40*]"); 613 return 0; 614 } 615 616 if ((conf & HT_CAP_INFO_SMPS_MASK) != (hw & HT_CAP_INFO_SMPS_MASK) && 617 (conf & HT_CAP_INFO_SMPS_MASK) != HT_CAP_INFO_SMPS_DISABLED) { 618 wpa_printf(MSG_ERROR, "Driver does not support configured " 619 "HT capability [SMPS-*]"); 620 return 0; 621 } 622 623 if ((conf & HT_CAP_INFO_GREEN_FIELD) && 624 !(hw & HT_CAP_INFO_GREEN_FIELD)) { 625 wpa_printf(MSG_ERROR, "Driver does not support configured " 626 "HT capability [GF]"); 627 return 0; 628 } 629 630 if ((conf & HT_CAP_INFO_SHORT_GI20MHZ) && 631 !(hw & HT_CAP_INFO_SHORT_GI20MHZ)) { 632 wpa_printf(MSG_ERROR, "Driver does not support configured " 633 "HT capability [SHORT-GI-20]"); 634 return 0; 635 } 636 637 if ((conf & HT_CAP_INFO_SHORT_GI40MHZ) && 638 !(hw & HT_CAP_INFO_SHORT_GI40MHZ)) { 639 wpa_printf(MSG_ERROR, "Driver does not support configured " 640 "HT capability [SHORT-GI-40]"); 641 return 0; 642 } 643 644 if ((conf & HT_CAP_INFO_TX_STBC) && !(hw & HT_CAP_INFO_TX_STBC)) { 645 wpa_printf(MSG_ERROR, "Driver does not support configured " 646 "HT capability [TX-STBC]"); 647 return 0; 648 } 649 650 if ((conf & HT_CAP_INFO_RX_STBC_MASK) > 651 (hw & HT_CAP_INFO_RX_STBC_MASK)) { 652 wpa_printf(MSG_ERROR, "Driver does not support configured " 653 "HT capability [RX-STBC*]"); 654 return 0; 655 } 656 657 if ((conf & HT_CAP_INFO_DELAYED_BA) && 658 !(hw & HT_CAP_INFO_DELAYED_BA)) { 659 wpa_printf(MSG_ERROR, "Driver does not support configured " 660 "HT capability [DELAYED-BA]"); 661 return 0; 662 } 663 664 if ((conf & HT_CAP_INFO_MAX_AMSDU_SIZE) && 665 !(hw & HT_CAP_INFO_MAX_AMSDU_SIZE)) { 666 wpa_printf(MSG_ERROR, "Driver does not support configured " 667 "HT capability [MAX-AMSDU-7935]"); 668 return 0; 669 } 670 671 if ((conf & HT_CAP_INFO_DSSS_CCK40MHZ) && 672 !(hw & HT_CAP_INFO_DSSS_CCK40MHZ)) { 673 wpa_printf(MSG_ERROR, "Driver does not support configured " 674 "HT capability [DSSS_CCK-40]"); 675 return 0; 676 } 677 678 if ((conf & HT_CAP_INFO_PSMP_SUPP) && !(hw & HT_CAP_INFO_PSMP_SUPP)) { 679 wpa_printf(MSG_ERROR, "Driver does not support configured " 680 "HT capability [PSMP]"); 681 return 0; 682 } 683 684 if ((conf & HT_CAP_INFO_LSIG_TXOP_PROTECT_SUPPORT) && 685 !(hw & HT_CAP_INFO_LSIG_TXOP_PROTECT_SUPPORT)) { 686 wpa_printf(MSG_ERROR, "Driver does not support configured " 687 "HT capability [LSIG-TXOP-PROT]"); 688 return 0; 689 } 690 691 return 1; 692 } 693 694 695 #ifdef CONFIG_IEEE80211AC 696 697 static int ieee80211ac_cap_check(u32 hw, u32 conf, u32 cap, const char *name) 698 { 699 u32 req_cap = conf & cap; 700 701 /* 702 * Make sure we support all requested capabilities. 703 * NOTE: We assume that 'cap' represents a capability mask, 704 * not a discrete value. 705 */ 706 if ((hw & req_cap) != req_cap) { 707 wpa_printf(MSG_ERROR, "Driver does not support configured VHT capability [%s]", 708 name); 709 return 0; 710 } 711 return 1; 712 } 713 714 715 static int ieee80211ac_cap_check_max(u32 hw, u32 conf, u32 cap, 716 const char *name) 717 { 718 u32 hw_max = hw & cap; 719 u32 conf_val = conf & cap; 720 721 if (conf_val > hw_max) { 722 int offset = find_first_bit(cap); 723 wpa_printf(MSG_ERROR, "Configured VHT capability [%s] exceeds max value supported by the driver (%d > %d)", 724 name, conf_val >> offset, hw_max >> offset); 725 return 0; 726 } 727 return 1; 728 } 729 730 731 static int ieee80211ac_supported_vht_capab(struct hostapd_iface *iface) 732 { 733 u32 hw = iface->current_mode->vht_capab; 734 u32 conf = iface->conf->vht_capab; 735 736 wpa_printf(MSG_DEBUG, "hw vht capab: 0x%x, conf vht capab: 0x%x", 737 hw, conf); 738 739 #define VHT_CAP_CHECK(cap) \ 740 do { \ 741 if (!ieee80211ac_cap_check(hw, conf, cap, #cap)) \ 742 return 0; \ 743 } while (0) 744 745 #define VHT_CAP_CHECK_MAX(cap) \ 746 do { \ 747 if (!ieee80211ac_cap_check_max(hw, conf, cap, #cap)) \ 748 return 0; \ 749 } while (0) 750 751 VHT_CAP_CHECK_MAX(VHT_CAP_MAX_MPDU_LENGTH_MASK); 752 VHT_CAP_CHECK(VHT_CAP_SUPP_CHAN_WIDTH_160MHZ); 753 VHT_CAP_CHECK(VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ); 754 VHT_CAP_CHECK(VHT_CAP_RXLDPC); 755 VHT_CAP_CHECK(VHT_CAP_SHORT_GI_80); 756 VHT_CAP_CHECK(VHT_CAP_SHORT_GI_160); 757 VHT_CAP_CHECK(VHT_CAP_TXSTBC); 758 VHT_CAP_CHECK_MAX(VHT_CAP_RXSTBC_MASK); 759 VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMER_CAPABLE); 760 VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMEE_CAPABLE); 761 VHT_CAP_CHECK_MAX(VHT_CAP_BEAMFORMEE_STS_MAX); 762 VHT_CAP_CHECK_MAX(VHT_CAP_SOUNDING_DIMENSION_MAX); 763 VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMER_CAPABLE); 764 VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMEE_CAPABLE); 765 VHT_CAP_CHECK(VHT_CAP_VHT_TXOP_PS); 766 VHT_CAP_CHECK(VHT_CAP_HTC_VHT); 767 VHT_CAP_CHECK_MAX(VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT); 768 VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB); 769 VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB); 770 VHT_CAP_CHECK(VHT_CAP_RX_ANTENNA_PATTERN); 771 VHT_CAP_CHECK(VHT_CAP_TX_ANTENNA_PATTERN); 772 773 #undef VHT_CAP_CHECK 774 #undef VHT_CAP_CHECK_MAX 775 776 return 1; 777 } 778 #endif /* CONFIG_IEEE80211AC */ 779 780 #endif /* CONFIG_IEEE80211N */ 781 782 783 int hostapd_check_ht_capab(struct hostapd_iface *iface) 784 { 785 #ifdef CONFIG_IEEE80211N 786 int ret; 787 if (!iface->conf->ieee80211n) 788 return 0; 789 if (!ieee80211n_supported_ht_capab(iface)) 790 return -1; 791 #ifdef CONFIG_IEEE80211AC 792 if (!ieee80211ac_supported_vht_capab(iface)) 793 return -1; 794 #endif /* CONFIG_IEEE80211AC */ 795 ret = ieee80211n_check_40mhz(iface); 796 if (ret) 797 return ret; 798 if (!ieee80211n_allowed_ht40_channel_pair(iface)) 799 return -1; 800 #endif /* CONFIG_IEEE80211N */ 801 802 return 0; 803 } 804 805 806 static int hostapd_is_usable_chan(struct hostapd_iface *iface, 807 int channel, int primary) 808 { 809 int i; 810 struct hostapd_channel_data *chan; 811 812 for (i = 0; i < iface->current_mode->num_channels; i++) { 813 chan = &iface->current_mode->channels[i]; 814 if (chan->chan != channel) 815 continue; 816 817 if (!(chan->flag & HOSTAPD_CHAN_DISABLED)) 818 return 1; 819 820 wpa_printf(MSG_DEBUG, 821 "%schannel [%i] (%i) is disabled for use in AP mode, flags: 0x%x%s%s%s", 822 primary ? "" : "Configured HT40 secondary ", 823 i, chan->chan, chan->flag, 824 chan->flag & HOSTAPD_CHAN_NO_IBSS ? " NO-IBSS" : "", 825 chan->flag & HOSTAPD_CHAN_PASSIVE_SCAN ? 826 " PASSIVE-SCAN" : "", 827 chan->flag & HOSTAPD_CHAN_RADAR ? " RADAR" : ""); 828 } 829 830 return 0; 831 } 832 833 834 static int hostapd_is_usable_chans(struct hostapd_iface *iface) 835 { 836 if (!hostapd_is_usable_chan(iface, iface->conf->channel, 1)) 837 return 0; 838 839 if (!iface->conf->secondary_channel) 840 return 1; 841 842 return hostapd_is_usable_chan(iface, iface->conf->channel + 843 iface->conf->secondary_channel * 4, 0); 844 } 845 846 847 static enum hostapd_chan_status 848 hostapd_check_chans(struct hostapd_iface *iface) 849 { 850 if (iface->conf->channel) { 851 if (hostapd_is_usable_chans(iface)) 852 return HOSTAPD_CHAN_VALID; 853 else 854 return HOSTAPD_CHAN_INVALID; 855 } 856 857 /* 858 * The user set channel=0 or channel=acs_survey 859 * which is used to trigger ACS. 860 */ 861 862 switch (acs_init(iface)) { 863 case HOSTAPD_CHAN_ACS: 864 return HOSTAPD_CHAN_ACS; 865 case HOSTAPD_CHAN_VALID: 866 case HOSTAPD_CHAN_INVALID: 867 default: 868 return HOSTAPD_CHAN_INVALID; 869 } 870 } 871 872 873 static void hostapd_notify_bad_chans(struct hostapd_iface *iface) 874 { 875 hostapd_logger(iface->bss[0], NULL, 876 HOSTAPD_MODULE_IEEE80211, 877 HOSTAPD_LEVEL_WARNING, 878 "Configured channel (%d) not found from the " 879 "channel list of current mode (%d) %s", 880 iface->conf->channel, 881 iface->current_mode->mode, 882 hostapd_hw_mode_txt(iface->current_mode->mode)); 883 hostapd_logger(iface->bss[0], NULL, HOSTAPD_MODULE_IEEE80211, 884 HOSTAPD_LEVEL_WARNING, 885 "Hardware does not support configured channel"); 886 } 887 888 889 int hostapd_acs_completed(struct hostapd_iface *iface, int err) 890 { 891 int ret = -1; 892 893 if (err) 894 goto out; 895 896 switch (hostapd_check_chans(iface)) { 897 case HOSTAPD_CHAN_VALID: 898 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, 899 ACS_EVENT_COMPLETED "freq=%d channel=%d", 900 hostapd_hw_get_freq(iface->bss[0], 901 iface->conf->channel), 902 iface->conf->channel); 903 break; 904 case HOSTAPD_CHAN_ACS: 905 wpa_printf(MSG_ERROR, "ACS error - reported complete, but no result available"); 906 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_FAILED); 907 hostapd_notify_bad_chans(iface); 908 goto out; 909 case HOSTAPD_CHAN_INVALID: 910 default: 911 wpa_printf(MSG_ERROR, "ACS picked unusable channels"); 912 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_FAILED); 913 hostapd_notify_bad_chans(iface); 914 goto out; 915 } 916 917 ret = hostapd_check_ht_capab(iface); 918 if (ret < 0) 919 goto out; 920 if (ret == 1) { 921 wpa_printf(MSG_DEBUG, "Interface initialization will be completed in a callback"); 922 return 0; 923 } 924 925 ret = 0; 926 out: 927 return hostapd_setup_interface_complete(iface, ret); 928 } 929 930 931 /** 932 * hostapd_select_hw_mode - Select the hardware mode 933 * @iface: Pointer to interface data. 934 * Returns: 0 on success, < 0 on failure 935 * 936 * Sets up the hardware mode, channel, rates, and passive scanning 937 * based on the configuration. 938 */ 939 int hostapd_select_hw_mode(struct hostapd_iface *iface) 940 { 941 int i; 942 943 if (iface->num_hw_features < 1) 944 return -1; 945 946 iface->current_mode = NULL; 947 for (i = 0; i < iface->num_hw_features; i++) { 948 struct hostapd_hw_modes *mode = &iface->hw_features[i]; 949 if (mode->mode == iface->conf->hw_mode) { 950 iface->current_mode = mode; 951 break; 952 } 953 } 954 955 if (iface->current_mode == NULL) { 956 wpa_printf(MSG_ERROR, "Hardware does not support configured " 957 "mode"); 958 hostapd_logger(iface->bss[0], NULL, HOSTAPD_MODULE_IEEE80211, 959 HOSTAPD_LEVEL_WARNING, 960 "Hardware does not support configured mode " 961 "(%d) (hw_mode in hostapd.conf)", 962 (int) iface->conf->hw_mode); 963 return -2; 964 } 965 966 switch (hostapd_check_chans(iface)) { 967 case HOSTAPD_CHAN_VALID: 968 return 0; 969 case HOSTAPD_CHAN_ACS: /* ACS will run and later complete */ 970 return 1; 971 case HOSTAPD_CHAN_INVALID: 972 default: 973 hostapd_notify_bad_chans(iface); 974 return -3; 975 } 976 977 return 0; 978 } 979 980 981 const char * hostapd_hw_mode_txt(int mode) 982 { 983 switch (mode) { 984 case HOSTAPD_MODE_IEEE80211A: 985 return "IEEE 802.11a"; 986 case HOSTAPD_MODE_IEEE80211B: 987 return "IEEE 802.11b"; 988 case HOSTAPD_MODE_IEEE80211G: 989 return "IEEE 802.11g"; 990 case HOSTAPD_MODE_IEEE80211AD: 991 return "IEEE 802.11ad"; 992 default: 993 return "UNKNOWN"; 994 } 995 } 996 997 998 int hostapd_hw_get_freq(struct hostapd_data *hapd, int chan) 999 { 1000 int i; 1001 1002 if (!hapd->iface->current_mode) 1003 return 0; 1004 1005 for (i = 0; i < hapd->iface->current_mode->num_channels; i++) { 1006 struct hostapd_channel_data *ch = 1007 &hapd->iface->current_mode->channels[i]; 1008 if (ch->chan == chan) 1009 return ch->freq; 1010 } 1011 1012 return 0; 1013 } 1014 1015 1016 int hostapd_hw_get_channel(struct hostapd_data *hapd, int freq) 1017 { 1018 int i; 1019 1020 if (!hapd->iface->current_mode) 1021 return 0; 1022 1023 for (i = 0; i < hapd->iface->current_mode->num_channels; i++) { 1024 struct hostapd_channel_data *ch = 1025 &hapd->iface->current_mode->channels[i]; 1026 if (ch->freq == freq) 1027 return ch->chan; 1028 } 1029 1030 return 0; 1031 } 1032