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
hostapd_free_hw_features(struct hostapd_hw_modes * hw_features,size_t num_hw_features)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
dfs_info(struct hostapd_channel_data * chan)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
hostapd_get_hw_features(struct hostapd_iface * iface)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
hostapd_prepare_rates(struct hostapd_iface * iface,struct hostapd_hw_modes * mode)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
ieee80211n_allowed_ht40_channel_pair(struct hostapd_iface * iface)228 static int ieee80211n_allowed_ht40_channel_pair(struct hostapd_iface *iface)
229 {
230 int pri_chan, sec_chan;
231
232 pri_chan = iface->conf->channel;
233 sec_chan = pri_chan + iface->conf->secondary_channel * 4;
234
235 return allowed_ht40_channel_pair(iface->current_mode, pri_chan,
236 sec_chan);
237 }
238
239
ieee80211n_switch_pri_sec(struct hostapd_iface * iface)240 static void ieee80211n_switch_pri_sec(struct hostapd_iface *iface)
241 {
242 if (iface->conf->secondary_channel > 0) {
243 iface->conf->channel += 4;
244 iface->conf->secondary_channel = -1;
245 } else {
246 iface->conf->channel -= 4;
247 iface->conf->secondary_channel = 1;
248 }
249 }
250
251
ieee80211n_check_40mhz_5g(struct hostapd_iface * iface,struct wpa_scan_results * scan_res)252 static int ieee80211n_check_40mhz_5g(struct hostapd_iface *iface,
253 struct wpa_scan_results *scan_res)
254 {
255 int pri_chan, sec_chan;
256 int res;
257
258 pri_chan = iface->conf->channel;
259 sec_chan = pri_chan + iface->conf->secondary_channel * 4;
260
261 res = check_40mhz_5g(iface->current_mode, scan_res, pri_chan, sec_chan);
262
263 if (res == 2) {
264 if (iface->conf->no_pri_sec_switch) {
265 wpa_printf(MSG_DEBUG,
266 "Cannot switch PRI/SEC channels due to local constraint");
267 } else {
268 ieee80211n_switch_pri_sec(iface);
269 }
270 }
271
272 return !!res;
273 }
274
275
ieee80211n_check_40mhz_2g4(struct hostapd_iface * iface,struct wpa_scan_results * scan_res)276 static int ieee80211n_check_40mhz_2g4(struct hostapd_iface *iface,
277 struct wpa_scan_results *scan_res)
278 {
279 int pri_chan, sec_chan;
280
281 pri_chan = iface->conf->channel;
282 sec_chan = pri_chan + iface->conf->secondary_channel * 4;
283
284 return check_40mhz_2g4(iface->current_mode, scan_res, pri_chan,
285 sec_chan);
286 }
287
288
ieee80211n_check_scan(struct hostapd_iface * iface)289 static void ieee80211n_check_scan(struct hostapd_iface *iface)
290 {
291 struct wpa_scan_results *scan_res;
292 int oper40;
293 int res;
294
295 /* Check list of neighboring BSSes (from scan) to see whether 40 MHz is
296 * allowed per IEEE Std 802.11-2012, 10.15.3.2 */
297
298 iface->scan_cb = NULL;
299
300 scan_res = hostapd_driver_get_scan_results(iface->bss[0]);
301 if (scan_res == NULL) {
302 hostapd_setup_interface_complete(iface, 1);
303 return;
304 }
305
306 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A)
307 oper40 = ieee80211n_check_40mhz_5g(iface, scan_res);
308 else
309 oper40 = ieee80211n_check_40mhz_2g4(iface, scan_res);
310 wpa_scan_results_free(scan_res);
311
312 iface->secondary_ch = iface->conf->secondary_channel;
313 if (!oper40) {
314 wpa_printf(MSG_INFO, "20/40 MHz operation not permitted on "
315 "channel pri=%d sec=%d based on overlapping BSSes",
316 iface->conf->channel,
317 iface->conf->channel +
318 iface->conf->secondary_channel * 4);
319 iface->conf->secondary_channel = 0;
320 if (iface->drv_flags & WPA_DRIVER_FLAGS_HT_2040_COEX) {
321 /*
322 * TODO: Could consider scheduling another scan to check
323 * if channel width can be changed if no coex reports
324 * are received from associating stations.
325 */
326 }
327 }
328
329 res = ieee80211n_allowed_ht40_channel_pair(iface);
330 if (!res) {
331 iface->conf->secondary_channel = 0;
332 iface->conf->vht_oper_centr_freq_seg0_idx = 0;
333 iface->conf->vht_oper_centr_freq_seg1_idx = 0;
334 iface->conf->vht_oper_chwidth = VHT_CHANWIDTH_USE_HT;
335 res = 1;
336 wpa_printf(MSG_INFO, "Fallback to 20 MHz");
337 }
338
339 hostapd_setup_interface_complete(iface, !res);
340 }
341
342
ieee80211n_scan_channels_2g4(struct hostapd_iface * iface,struct wpa_driver_scan_params * params)343 static void ieee80211n_scan_channels_2g4(struct hostapd_iface *iface,
344 struct wpa_driver_scan_params *params)
345 {
346 /* Scan only the affected frequency range */
347 int pri_freq, sec_freq;
348 int affected_start, affected_end;
349 int i, pos;
350 struct hostapd_hw_modes *mode;
351
352 if (iface->current_mode == NULL)
353 return;
354
355 pri_freq = hostapd_hw_get_freq(iface->bss[0], iface->conf->channel);
356 if (iface->conf->secondary_channel > 0)
357 sec_freq = pri_freq + 20;
358 else
359 sec_freq = pri_freq - 20;
360 /*
361 * Note: Need to find the PRI channel also in cases where the affected
362 * channel is the SEC channel of a 40 MHz BSS, so need to include the
363 * scanning coverage here to be 40 MHz from the center frequency.
364 */
365 affected_start = (pri_freq + sec_freq) / 2 - 40;
366 affected_end = (pri_freq + sec_freq) / 2 + 40;
367 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz",
368 affected_start, affected_end);
369
370 mode = iface->current_mode;
371 params->freqs = os_calloc(mode->num_channels + 1, sizeof(int));
372 if (params->freqs == NULL)
373 return;
374 pos = 0;
375
376 for (i = 0; i < mode->num_channels; i++) {
377 struct hostapd_channel_data *chan = &mode->channels[i];
378 if (chan->flag & HOSTAPD_CHAN_DISABLED)
379 continue;
380 if (chan->freq < affected_start ||
381 chan->freq > affected_end)
382 continue;
383 params->freqs[pos++] = chan->freq;
384 }
385 }
386
387
ieee80211n_scan_channels_5g(struct hostapd_iface * iface,struct wpa_driver_scan_params * params)388 static void ieee80211n_scan_channels_5g(struct hostapd_iface *iface,
389 struct wpa_driver_scan_params *params)
390 {
391 /* Scan only the affected frequency range */
392 int pri_freq;
393 int affected_start, affected_end;
394 int i, pos;
395 struct hostapd_hw_modes *mode;
396
397 if (iface->current_mode == NULL)
398 return;
399
400 pri_freq = hostapd_hw_get_freq(iface->bss[0], iface->conf->channel);
401 if (iface->conf->secondary_channel > 0) {
402 affected_start = pri_freq - 10;
403 affected_end = pri_freq + 30;
404 } else {
405 affected_start = pri_freq - 30;
406 affected_end = pri_freq + 10;
407 }
408 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz",
409 affected_start, affected_end);
410
411 mode = iface->current_mode;
412 params->freqs = os_calloc(mode->num_channels + 1, sizeof(int));
413 if (params->freqs == NULL)
414 return;
415 pos = 0;
416
417 for (i = 0; i < mode->num_channels; i++) {
418 struct hostapd_channel_data *chan = &mode->channels[i];
419 if (chan->flag & HOSTAPD_CHAN_DISABLED)
420 continue;
421 if (chan->freq < affected_start ||
422 chan->freq > affected_end)
423 continue;
424 params->freqs[pos++] = chan->freq;
425 }
426 }
427
428
ap_ht40_scan_retry(void * eloop_data,void * user_data)429 static void ap_ht40_scan_retry(void *eloop_data, void *user_data)
430 {
431 #define HT2040_COEX_SCAN_RETRY 15
432 struct hostapd_iface *iface = eloop_data;
433 struct wpa_driver_scan_params params;
434 int ret;
435
436 os_memset(¶ms, 0, sizeof(params));
437 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G)
438 ieee80211n_scan_channels_2g4(iface, ¶ms);
439 else
440 ieee80211n_scan_channels_5g(iface, ¶ms);
441
442 ret = hostapd_driver_scan(iface->bss[0], ¶ms);
443 iface->num_ht40_scan_tries++;
444 os_free(params.freqs);
445
446 if (ret == -EBUSY &&
447 iface->num_ht40_scan_tries < HT2040_COEX_SCAN_RETRY) {
448 wpa_printf(MSG_ERROR,
449 "Failed to request a scan of neighboring BSSes ret=%d (%s) - try to scan again (attempt %d)",
450 ret, strerror(-ret), iface->num_ht40_scan_tries);
451 eloop_register_timeout(1, 0, ap_ht40_scan_retry, iface, NULL);
452 return;
453 }
454
455 if (ret == 0) {
456 iface->scan_cb = ieee80211n_check_scan;
457 return;
458 }
459
460 wpa_printf(MSG_DEBUG,
461 "Failed to request a scan in device, bringing up in HT20 mode");
462 iface->conf->secondary_channel = 0;
463 iface->conf->ht_capab &= ~HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET;
464 hostapd_setup_interface_complete(iface, 0);
465 }
466
467
hostapd_stop_setup_timers(struct hostapd_iface * iface)468 void hostapd_stop_setup_timers(struct hostapd_iface *iface)
469 {
470 eloop_cancel_timeout(ap_ht40_scan_retry, iface, NULL);
471 }
472
473
ieee80211n_check_40mhz(struct hostapd_iface * iface)474 static int ieee80211n_check_40mhz(struct hostapd_iface *iface)
475 {
476 struct wpa_driver_scan_params params;
477 int ret;
478
479 /* Check that HT40 is used and PRI / SEC switch is allowed */
480 if (!iface->conf->secondary_channel || iface->conf->no_pri_sec_switch)
481 return 0;
482
483 hostapd_set_state(iface, HAPD_IFACE_HT_SCAN);
484 wpa_printf(MSG_DEBUG, "Scan for neighboring BSSes prior to enabling "
485 "40 MHz channel");
486 os_memset(¶ms, 0, sizeof(params));
487 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G)
488 ieee80211n_scan_channels_2g4(iface, ¶ms);
489 else
490 ieee80211n_scan_channels_5g(iface, ¶ms);
491
492 ret = hostapd_driver_scan(iface->bss[0], ¶ms);
493 os_free(params.freqs);
494
495 if (ret == -EBUSY) {
496 wpa_printf(MSG_ERROR,
497 "Failed to request a scan of neighboring BSSes ret=%d (%s) - try to scan again",
498 ret, strerror(-ret));
499 iface->num_ht40_scan_tries = 1;
500 eloop_cancel_timeout(ap_ht40_scan_retry, iface, NULL);
501 eloop_register_timeout(1, 0, ap_ht40_scan_retry, iface, NULL);
502 return 1;
503 }
504
505 if (ret < 0) {
506 wpa_printf(MSG_ERROR,
507 "Failed to request a scan of neighboring BSSes ret=%d (%s)",
508 ret, strerror(-ret));
509 return -1;
510 }
511
512 iface->scan_cb = ieee80211n_check_scan;
513 return 1;
514 }
515
516
ieee80211n_supported_ht_capab(struct hostapd_iface * iface)517 static int ieee80211n_supported_ht_capab(struct hostapd_iface *iface)
518 {
519 u16 hw = iface->current_mode->ht_capab;
520 u16 conf = iface->conf->ht_capab;
521
522 if ((conf & HT_CAP_INFO_LDPC_CODING_CAP) &&
523 !(hw & HT_CAP_INFO_LDPC_CODING_CAP)) {
524 wpa_printf(MSG_ERROR, "Driver does not support configured "
525 "HT capability [LDPC]");
526 return 0;
527 }
528
529 /*
530 * Driver ACS chosen channel may not be HT40 due to internal driver
531 * restrictions.
532 */
533 if (!iface->conf->acs && (conf & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET) &&
534 !(hw & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) {
535 wpa_printf(MSG_ERROR, "Driver does not support configured "
536 "HT capability [HT40*]");
537 return 0;
538 }
539
540 switch (conf & HT_CAP_INFO_SMPS_MASK) {
541 case HT_CAP_INFO_SMPS_STATIC:
542 if (!(iface->smps_modes & WPA_DRIVER_SMPS_MODE_STATIC)) {
543 wpa_printf(MSG_ERROR,
544 "Driver does not support configured HT capability [SMPS-STATIC]");
545 return 0;
546 }
547 break;
548 case HT_CAP_INFO_SMPS_DYNAMIC:
549 if (!(iface->smps_modes & WPA_DRIVER_SMPS_MODE_DYNAMIC)) {
550 wpa_printf(MSG_ERROR,
551 "Driver does not support configured HT capability [SMPS-DYNAMIC]");
552 return 0;
553 }
554 break;
555 case HT_CAP_INFO_SMPS_DISABLED:
556 default:
557 break;
558 }
559
560 if ((conf & HT_CAP_INFO_GREEN_FIELD) &&
561 !(hw & HT_CAP_INFO_GREEN_FIELD)) {
562 wpa_printf(MSG_ERROR, "Driver does not support configured "
563 "HT capability [GF]");
564 return 0;
565 }
566
567 if ((conf & HT_CAP_INFO_SHORT_GI20MHZ) &&
568 !(hw & HT_CAP_INFO_SHORT_GI20MHZ)) {
569 wpa_printf(MSG_ERROR, "Driver does not support configured "
570 "HT capability [SHORT-GI-20]");
571 return 0;
572 }
573
574 if ((conf & HT_CAP_INFO_SHORT_GI40MHZ) &&
575 !(hw & HT_CAP_INFO_SHORT_GI40MHZ)) {
576 wpa_printf(MSG_ERROR, "Driver does not support configured "
577 "HT capability [SHORT-GI-40]");
578 return 0;
579 }
580
581 if ((conf & HT_CAP_INFO_TX_STBC) && !(hw & HT_CAP_INFO_TX_STBC)) {
582 wpa_printf(MSG_ERROR, "Driver does not support configured "
583 "HT capability [TX-STBC]");
584 return 0;
585 }
586
587 if ((conf & HT_CAP_INFO_RX_STBC_MASK) >
588 (hw & HT_CAP_INFO_RX_STBC_MASK)) {
589 wpa_printf(MSG_ERROR, "Driver does not support configured "
590 "HT capability [RX-STBC*]");
591 return 0;
592 }
593
594 if ((conf & HT_CAP_INFO_DELAYED_BA) &&
595 !(hw & HT_CAP_INFO_DELAYED_BA)) {
596 wpa_printf(MSG_ERROR, "Driver does not support configured "
597 "HT capability [DELAYED-BA]");
598 return 0;
599 }
600
601 if ((conf & HT_CAP_INFO_MAX_AMSDU_SIZE) &&
602 !(hw & HT_CAP_INFO_MAX_AMSDU_SIZE)) {
603 wpa_printf(MSG_ERROR, "Driver does not support configured "
604 "HT capability [MAX-AMSDU-7935]");
605 return 0;
606 }
607
608 if ((conf & HT_CAP_INFO_DSSS_CCK40MHZ) &&
609 !(hw & HT_CAP_INFO_DSSS_CCK40MHZ)) {
610 wpa_printf(MSG_ERROR, "Driver does not support configured "
611 "HT capability [DSSS_CCK-40]");
612 return 0;
613 }
614
615 if ((conf & HT_CAP_INFO_LSIG_TXOP_PROTECT_SUPPORT) &&
616 !(hw & HT_CAP_INFO_LSIG_TXOP_PROTECT_SUPPORT)) {
617 wpa_printf(MSG_ERROR, "Driver does not support configured "
618 "HT capability [LSIG-TXOP-PROT]");
619 return 0;
620 }
621
622 return 1;
623 }
624
625
626 #ifdef CONFIG_IEEE80211AC
ieee80211ac_supported_vht_capab(struct hostapd_iface * iface)627 static int ieee80211ac_supported_vht_capab(struct hostapd_iface *iface)
628 {
629 struct hostapd_hw_modes *mode = iface->current_mode;
630 u32 hw = mode->vht_capab;
631 u32 conf = iface->conf->vht_capab;
632
633 wpa_printf(MSG_DEBUG, "hw vht capab: 0x%x, conf vht capab: 0x%x",
634 hw, conf);
635
636 if (mode->mode == HOSTAPD_MODE_IEEE80211G &&
637 iface->conf->bss[0]->vendor_vht &&
638 mode->vht_capab == 0 && iface->hw_features) {
639 int i;
640
641 for (i = 0; i < iface->num_hw_features; i++) {
642 if (iface->hw_features[i].mode ==
643 HOSTAPD_MODE_IEEE80211A) {
644 mode = &iface->hw_features[i];
645 hw = mode->vht_capab;
646 wpa_printf(MSG_DEBUG,
647 "update hw vht capab based on 5 GHz band: 0x%x",
648 hw);
649 break;
650 }
651 }
652 }
653
654 return ieee80211ac_cap_check(hw, conf);
655 }
656 #endif /* CONFIG_IEEE80211AC */
657
658 #endif /* CONFIG_IEEE80211N */
659
660
hostapd_check_ht_capab(struct hostapd_iface * iface)661 int hostapd_check_ht_capab(struct hostapd_iface *iface)
662 {
663 #ifdef CONFIG_IEEE80211N
664 int ret;
665 if (!iface->conf->ieee80211n)
666 return 0;
667
668 if (iface->current_mode->mode != HOSTAPD_MODE_IEEE80211B &&
669 iface->current_mode->mode != HOSTAPD_MODE_IEEE80211G &&
670 (iface->conf->ht_capab & HT_CAP_INFO_DSSS_CCK40MHZ)) {
671 wpa_printf(MSG_DEBUG,
672 "Disable HT capability [DSSS_CCK-40] on 5 GHz band");
673 iface->conf->ht_capab &= ~HT_CAP_INFO_DSSS_CCK40MHZ;
674 }
675
676 if (!ieee80211n_supported_ht_capab(iface))
677 return -1;
678 #ifdef CONFIG_IEEE80211AC
679 if (iface->conf->ieee80211ac &&
680 !ieee80211ac_supported_vht_capab(iface))
681 return -1;
682 #endif /* CONFIG_IEEE80211AC */
683 ret = ieee80211n_check_40mhz(iface);
684 if (ret)
685 return ret;
686 if (!ieee80211n_allowed_ht40_channel_pair(iface))
687 return -1;
688 #endif /* CONFIG_IEEE80211N */
689
690 return 0;
691 }
692
693
hostapd_is_usable_chan(struct hostapd_iface * iface,int channel,int primary)694 static int hostapd_is_usable_chan(struct hostapd_iface *iface,
695 int channel, int primary)
696 {
697 struct hostapd_channel_data *chan;
698
699 if (!iface->current_mode)
700 return 0;
701
702 chan = hw_get_channel_chan(iface->current_mode, channel, NULL);
703 if (!chan)
704 return 0;
705
706 if ((primary && chan_pri_allowed(chan)) ||
707 (!primary && !(chan->flag & HOSTAPD_CHAN_DISABLED)))
708 return 1;
709
710 wpa_printf(MSG_INFO,
711 "Channel %d (%s) not allowed for AP mode, flags: 0x%x%s%s",
712 channel, primary ? "primary" : "secondary",
713 chan->flag,
714 chan->flag & HOSTAPD_CHAN_NO_IR ? " NO-IR" : "",
715 chan->flag & HOSTAPD_CHAN_RADAR ? " RADAR" : "");
716 return 0;
717 }
718
719
hostapd_is_usable_chans(struct hostapd_iface * iface)720 static int hostapd_is_usable_chans(struct hostapd_iface *iface)
721 {
722 int secondary_chan;
723 struct hostapd_channel_data *pri_chan;
724
725 pri_chan = hw_get_channel_chan(iface->current_mode,
726 iface->conf->channel, NULL);
727 if (!pri_chan)
728 return 0;
729
730 if (!hostapd_is_usable_chan(iface, iface->conf->channel, 1))
731 return 0;
732
733 if (!iface->conf->secondary_channel)
734 return 1;
735
736 if (!iface->conf->ht40_plus_minus_allowed)
737 return hostapd_is_usable_chan(
738 iface, iface->conf->channel +
739 iface->conf->secondary_channel * 4, 0);
740
741 /* Both HT40+ and HT40- are set, pick a valid secondary channel */
742 secondary_chan = iface->conf->channel + 4;
743 if (hostapd_is_usable_chan(iface, secondary_chan, 0) &&
744 (pri_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40P)) {
745 iface->conf->secondary_channel = 1;
746 return 1;
747 }
748
749 secondary_chan = iface->conf->channel - 4;
750 if (hostapd_is_usable_chan(iface, secondary_chan, 0) &&
751 (pri_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40M)) {
752 iface->conf->secondary_channel = -1;
753 return 1;
754 }
755
756 return 0;
757 }
758
759
760 static enum hostapd_chan_status
hostapd_check_chans(struct hostapd_iface * iface)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
hostapd_notify_bad_chans(struct hostapd_iface * iface)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
hostapd_acs_completed(struct hostapd_iface * iface,int err)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 */
hostapd_select_hw_mode(struct hostapd_iface * iface)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
hostapd_hw_mode_txt(int mode)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
hostapd_hw_get_freq(struct hostapd_data * hapd,int chan)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
hostapd_hw_get_channel(struct hostapd_data * hapd,int freq)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 if (hapd->iface->current_mode) {
940 channel = hw_get_chan(hapd->iface->current_mode, freq);
941 if (channel)
942 return channel;
943 }
944
945 /* Check other available modes since the channel list for the current
946 * mode did not include the specified frequency. */
947 if (!hapd->iface->hw_features)
948 return 0;
949 for (i = 0; i < hapd->iface->num_hw_features; i++) {
950 mode = &hapd->iface->hw_features[i];
951 channel = hw_get_chan(mode, freq);
952 if (channel)
953 return channel;
954 }
955 return 0;
956 }
957