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