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 hostapd_set_oper_centr_freq_seg0_idx(iface->conf, 0);
333 hostapd_set_oper_centr_freq_seg1_idx(iface->conf, 0);
334 hostapd_set_oper_chwidth(iface->conf, 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
659 #ifdef CONFIG_IEEE80211AX
ieee80211ax_supported_he_capab(struct hostapd_iface * iface)660 static int ieee80211ax_supported_he_capab(struct hostapd_iface *iface)
661 {
662 return 1;
663 }
664 #endif /* CONFIG_IEEE80211AX */
665
666 #endif /* CONFIG_IEEE80211N */
667
668
hostapd_check_ht_capab(struct hostapd_iface * iface)669 int hostapd_check_ht_capab(struct hostapd_iface *iface)
670 {
671 #ifdef CONFIG_IEEE80211N
672 int ret;
673 if (!iface->conf->ieee80211n)
674 return 0;
675
676 if (iface->current_mode->mode != HOSTAPD_MODE_IEEE80211B &&
677 iface->current_mode->mode != HOSTAPD_MODE_IEEE80211G &&
678 (iface->conf->ht_capab & HT_CAP_INFO_DSSS_CCK40MHZ)) {
679 wpa_printf(MSG_DEBUG,
680 "Disable HT capability [DSSS_CCK-40] on 5 GHz band");
681 iface->conf->ht_capab &= ~HT_CAP_INFO_DSSS_CCK40MHZ;
682 }
683
684 if (!ieee80211n_supported_ht_capab(iface))
685 return -1;
686 #ifdef CONFIG_IEEE80211AX
687 if (iface->conf->ieee80211ax &&
688 !ieee80211ax_supported_he_capab(iface))
689 return -1;
690 #endif /* CONFIG_IEEE80211AX */
691 #ifdef CONFIG_IEEE80211AC
692 if (iface->conf->ieee80211ac &&
693 !ieee80211ac_supported_vht_capab(iface))
694 return -1;
695 #endif /* CONFIG_IEEE80211AC */
696 ret = ieee80211n_check_40mhz(iface);
697 if (ret)
698 return ret;
699 if (!ieee80211n_allowed_ht40_channel_pair(iface))
700 return -1;
701 #endif /* CONFIG_IEEE80211N */
702
703 return 0;
704 }
705
706
hostapd_is_usable_chan(struct hostapd_iface * iface,int channel,int primary)707 static int hostapd_is_usable_chan(struct hostapd_iface *iface,
708 int channel, int primary)
709 {
710 struct hostapd_channel_data *chan;
711
712 if (!iface->current_mode)
713 return 0;
714
715 chan = hw_get_channel_chan(iface->current_mode, channel, NULL);
716 if (!chan)
717 return 0;
718
719 if ((primary && chan_pri_allowed(chan)) ||
720 (!primary && !(chan->flag & HOSTAPD_CHAN_DISABLED)))
721 return 1;
722
723 wpa_printf(MSG_INFO,
724 "Channel %d (%s) not allowed for AP mode, flags: 0x%x%s%s",
725 channel, primary ? "primary" : "secondary",
726 chan->flag,
727 chan->flag & HOSTAPD_CHAN_NO_IR ? " NO-IR" : "",
728 chan->flag & HOSTAPD_CHAN_RADAR ? " RADAR" : "");
729 return 0;
730 }
731
732
hostapd_is_usable_chans(struct hostapd_iface * iface)733 static int hostapd_is_usable_chans(struct hostapd_iface *iface)
734 {
735 int secondary_chan;
736 struct hostapd_channel_data *pri_chan;
737
738 pri_chan = hw_get_channel_chan(iface->current_mode,
739 iface->conf->channel, NULL);
740 if (!pri_chan)
741 return 0;
742
743 if (!hostapd_is_usable_chan(iface, iface->conf->channel, 1))
744 return 0;
745
746 if (!iface->conf->secondary_channel)
747 return 1;
748
749 if (!iface->conf->ht40_plus_minus_allowed)
750 return hostapd_is_usable_chan(
751 iface, iface->conf->channel +
752 iface->conf->secondary_channel * 4, 0);
753
754 /* Both HT40+ and HT40- are set, pick a valid secondary channel */
755 secondary_chan = iface->conf->channel + 4;
756 if (hostapd_is_usable_chan(iface, secondary_chan, 0) &&
757 (pri_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40P)) {
758 iface->conf->secondary_channel = 1;
759 return 1;
760 }
761
762 secondary_chan = iface->conf->channel - 4;
763 if (hostapd_is_usable_chan(iface, secondary_chan, 0) &&
764 (pri_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40M)) {
765 iface->conf->secondary_channel = -1;
766 return 1;
767 }
768
769 return 0;
770 }
771
772
773 static enum hostapd_chan_status
hostapd_check_chans(struct hostapd_iface * iface)774 hostapd_check_chans(struct hostapd_iface *iface)
775 {
776 if (iface->conf->channel) {
777 if (hostapd_is_usable_chans(iface))
778 return HOSTAPD_CHAN_VALID;
779 else
780 return HOSTAPD_CHAN_INVALID;
781 }
782
783 /*
784 * The user set channel=0 or channel=acs_survey
785 * which is used to trigger ACS.
786 */
787
788 switch (acs_init(iface)) {
789 case HOSTAPD_CHAN_ACS:
790 return HOSTAPD_CHAN_ACS;
791 case HOSTAPD_CHAN_VALID:
792 case HOSTAPD_CHAN_INVALID:
793 default:
794 return HOSTAPD_CHAN_INVALID;
795 }
796 }
797
798
hostapd_notify_bad_chans(struct hostapd_iface * iface)799 static void hostapd_notify_bad_chans(struct hostapd_iface *iface)
800 {
801 if (!iface->current_mode) {
802 hostapd_logger(iface->bss[0], NULL, HOSTAPD_MODULE_IEEE80211,
803 HOSTAPD_LEVEL_WARNING,
804 "Hardware does not support configured mode");
805 return;
806 }
807 hostapd_logger(iface->bss[0], NULL,
808 HOSTAPD_MODULE_IEEE80211,
809 HOSTAPD_LEVEL_WARNING,
810 "Configured channel (%d) not found from the "
811 "channel list of current mode (%d) %s",
812 iface->conf->channel,
813 iface->current_mode->mode,
814 hostapd_hw_mode_txt(iface->current_mode->mode));
815 hostapd_logger(iface->bss[0], NULL, HOSTAPD_MODULE_IEEE80211,
816 HOSTAPD_LEVEL_WARNING,
817 "Hardware does not support configured channel");
818 }
819
820
hostapd_acs_completed(struct hostapd_iface * iface,int err)821 int hostapd_acs_completed(struct hostapd_iface *iface, int err)
822 {
823 int ret = -1;
824
825 if (err)
826 goto out;
827
828 switch (hostapd_check_chans(iface)) {
829 case HOSTAPD_CHAN_VALID:
830 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO,
831 ACS_EVENT_COMPLETED "freq=%d channel=%d",
832 hostapd_hw_get_freq(iface->bss[0],
833 iface->conf->channel),
834 iface->conf->channel);
835 break;
836 case HOSTAPD_CHAN_ACS:
837 wpa_printf(MSG_ERROR, "ACS error - reported complete, but no result available");
838 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_FAILED);
839 hostapd_notify_bad_chans(iface);
840 goto out;
841 case HOSTAPD_CHAN_INVALID:
842 default:
843 wpa_printf(MSG_ERROR, "ACS picked unusable channels");
844 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_FAILED);
845 hostapd_notify_bad_chans(iface);
846 goto out;
847 }
848
849 ret = hostapd_check_ht_capab(iface);
850 if (ret < 0)
851 goto out;
852 if (ret == 1) {
853 wpa_printf(MSG_DEBUG, "Interface initialization will be completed in a callback");
854 return 0;
855 }
856
857 ret = 0;
858 out:
859 return hostapd_setup_interface_complete(iface, ret);
860 }
861
862
863 /**
864 * hostapd_select_hw_mode - Select the hardware mode
865 * @iface: Pointer to interface data.
866 * Returns: 0 on success, < 0 on failure
867 *
868 * Sets up the hardware mode, channel, rates, and passive scanning
869 * based on the configuration.
870 */
hostapd_select_hw_mode(struct hostapd_iface * iface)871 int hostapd_select_hw_mode(struct hostapd_iface *iface)
872 {
873 int i;
874
875 if (iface->num_hw_features < 1)
876 return -1;
877
878 if ((iface->conf->hw_mode == HOSTAPD_MODE_IEEE80211G ||
879 iface->conf->ieee80211n || iface->conf->ieee80211ac ||
880 iface->conf->ieee80211ax) &&
881 iface->conf->channel == 14) {
882 wpa_printf(MSG_INFO, "Disable OFDM/HT/VHT/HE on channel 14");
883 iface->conf->hw_mode = HOSTAPD_MODE_IEEE80211B;
884 iface->conf->ieee80211n = 0;
885 iface->conf->ieee80211ac = 0;
886 iface->conf->ieee80211ax = 0;
887 }
888
889 iface->current_mode = NULL;
890 for (i = 0; i < iface->num_hw_features; i++) {
891 struct hostapd_hw_modes *mode = &iface->hw_features[i];
892 if (mode->mode == iface->conf->hw_mode) {
893 iface->current_mode = mode;
894 break;
895 }
896 }
897
898 if (iface->current_mode == NULL) {
899 if (!(iface->drv_flags & WPA_DRIVER_FLAGS_ACS_OFFLOAD) ||
900 !(iface->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_HW_MODE_ANY))
901 {
902 wpa_printf(MSG_ERROR,
903 "Hardware does not support configured mode");
904 hostapd_logger(iface->bss[0], NULL,
905 HOSTAPD_MODULE_IEEE80211,
906 HOSTAPD_LEVEL_WARNING,
907 "Hardware does not support configured mode (%d) (hw_mode in hostapd.conf)",
908 (int) iface->conf->hw_mode);
909 return -2;
910 }
911 }
912
913 switch (hostapd_check_chans(iface)) {
914 case HOSTAPD_CHAN_VALID:
915 return 0;
916 case HOSTAPD_CHAN_ACS: /* ACS will run and later complete */
917 return 1;
918 case HOSTAPD_CHAN_INVALID:
919 default:
920 hostapd_notify_bad_chans(iface);
921 return -3;
922 }
923 }
924
925
hostapd_hw_mode_txt(int mode)926 const char * hostapd_hw_mode_txt(int mode)
927 {
928 switch (mode) {
929 case HOSTAPD_MODE_IEEE80211A:
930 return "IEEE 802.11a";
931 case HOSTAPD_MODE_IEEE80211B:
932 return "IEEE 802.11b";
933 case HOSTAPD_MODE_IEEE80211G:
934 return "IEEE 802.11g";
935 case HOSTAPD_MODE_IEEE80211AD:
936 return "IEEE 802.11ad";
937 default:
938 return "UNKNOWN";
939 }
940 }
941
942
hostapd_hw_get_freq(struct hostapd_data * hapd,int chan)943 int hostapd_hw_get_freq(struct hostapd_data *hapd, int chan)
944 {
945 return hw_get_freq(hapd->iface->current_mode, chan);
946 }
947
948
hostapd_hw_get_channel(struct hostapd_data * hapd,int freq)949 int hostapd_hw_get_channel(struct hostapd_data *hapd, int freq)
950 {
951 int i, channel;
952 struct hostapd_hw_modes *mode;
953
954 if (hapd->iface->current_mode) {
955 channel = hw_get_chan(hapd->iface->current_mode, freq);
956 if (channel)
957 return channel;
958 }
959
960 /* Check other available modes since the channel list for the current
961 * mode did not include the specified frequency. */
962 if (!hapd->iface->hw_features)
963 return 0;
964 for (i = 0; i < hapd->iface->num_hw_features; i++) {
965 mode = &hapd->iface->hw_features[i];
966 channel = hw_get_chan(mode, freq);
967 if (channel)
968 return channel;
969 }
970 return 0;
971 }
972