libeap/src/common/hw_features_common.c

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