src/ap/hw_features.c

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