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 if (!iface->conf->secondary_channel)
233 return 1; /* HT40 not used */
234
235 pri_chan = iface->conf->channel;
236 sec_chan = pri_chan + iface->conf->secondary_channel * 4;
237
238 return allowed_ht40_channel_pair(iface->current_mode, pri_chan,
239 sec_chan);
240 }
241
242
ieee80211n_switch_pri_sec(struct hostapd_iface * iface)243 static void ieee80211n_switch_pri_sec(struct hostapd_iface *iface)
244 {
245 if (iface->conf->secondary_channel > 0) {
246 iface->conf->channel += 4;
247 iface->conf->secondary_channel = -1;
248 } else {
249 iface->conf->channel -= 4;
250 iface->conf->secondary_channel = 1;
251 }
252 }
253
254
ieee80211n_check_40mhz_5g(struct hostapd_iface * iface,struct wpa_scan_results * scan_res)255 static int ieee80211n_check_40mhz_5g(struct hostapd_iface *iface,
256 struct wpa_scan_results *scan_res)
257 {
258 int pri_chan, sec_chan;
259 int res;
260
261 pri_chan = iface->conf->channel;
262 sec_chan = pri_chan + iface->conf->secondary_channel * 4;
263
264 res = check_40mhz_5g(iface->current_mode, scan_res, pri_chan, sec_chan);
265
266 if (res == 2) {
267 if (iface->conf->no_pri_sec_switch) {
268 wpa_printf(MSG_DEBUG,
269 "Cannot switch PRI/SEC channels due to local constraint");
270 } else {
271 ieee80211n_switch_pri_sec(iface);
272 }
273 }
274
275 return !!res;
276 }
277
278
ieee80211n_check_40mhz_2g4(struct hostapd_iface * iface,struct wpa_scan_results * scan_res)279 static int ieee80211n_check_40mhz_2g4(struct hostapd_iface *iface,
280 struct wpa_scan_results *scan_res)
281 {
282 int pri_chan, sec_chan;
283
284 pri_chan = iface->conf->channel;
285 sec_chan = pri_chan + iface->conf->secondary_channel * 4;
286
287 return check_40mhz_2g4(iface->current_mode, scan_res, pri_chan,
288 sec_chan);
289 }
290
291
ieee80211n_check_scan(struct hostapd_iface * iface)292 static void ieee80211n_check_scan(struct hostapd_iface *iface)
293 {
294 struct wpa_scan_results *scan_res;
295 int oper40;
296 int res;
297
298 /* Check list of neighboring BSSes (from scan) to see whether 40 MHz is
299 * allowed per IEEE Std 802.11-2012, 10.15.3.2 */
300
301 iface->scan_cb = NULL;
302
303 scan_res = hostapd_driver_get_scan_results(iface->bss[0]);
304 if (scan_res == NULL) {
305 hostapd_setup_interface_complete(iface, 1);
306 return;
307 }
308
309 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A)
310 oper40 = ieee80211n_check_40mhz_5g(iface, scan_res);
311 else
312 oper40 = ieee80211n_check_40mhz_2g4(iface, scan_res);
313 wpa_scan_results_free(scan_res);
314
315 iface->secondary_ch = iface->conf->secondary_channel;
316 if (!oper40) {
317 wpa_printf(MSG_INFO, "20/40 MHz operation not permitted on "
318 "channel pri=%d sec=%d based on overlapping BSSes",
319 iface->conf->channel,
320 iface->conf->channel +
321 iface->conf->secondary_channel * 4);
322 iface->conf->secondary_channel = 0;
323 if (iface->drv_flags & WPA_DRIVER_FLAGS_HT_2040_COEX) {
324 /*
325 * TODO: Could consider scheduling another scan to check
326 * if channel width can be changed if no coex reports
327 * are received from associating stations.
328 */
329 }
330 }
331
332 res = ieee80211n_allowed_ht40_channel_pair(iface);
333 if (!res) {
334 iface->conf->secondary_channel = 0;
335 iface->conf->vht_oper_centr_freq_seg0_idx = 0;
336 iface->conf->vht_oper_centr_freq_seg1_idx = 0;
337 iface->conf->vht_oper_chwidth = VHT_CHANWIDTH_USE_HT;
338 res = 1;
339 wpa_printf(MSG_INFO, "Fallback to 20 MHz");
340 }
341
342 hostapd_setup_interface_complete(iface, !res);
343 }
344
345
ieee80211n_scan_channels_2g4(struct hostapd_iface * iface,struct wpa_driver_scan_params * params)346 static void ieee80211n_scan_channels_2g4(struct hostapd_iface *iface,
347 struct wpa_driver_scan_params *params)
348 {
349 /* Scan only the affected frequency range */
350 int pri_freq, sec_freq;
351 int affected_start, affected_end;
352 int i, pos;
353 struct hostapd_hw_modes *mode;
354
355 if (iface->current_mode == NULL)
356 return;
357
358 pri_freq = hostapd_hw_get_freq(iface->bss[0], iface->conf->channel);
359 if (iface->conf->secondary_channel > 0)
360 sec_freq = pri_freq + 20;
361 else
362 sec_freq = pri_freq - 20;
363 /*
364 * Note: Need to find the PRI channel also in cases where the affected
365 * channel is the SEC channel of a 40 MHz BSS, so need to include the
366 * scanning coverage here to be 40 MHz from the center frequency.
367 */
368 affected_start = (pri_freq + sec_freq) / 2 - 40;
369 affected_end = (pri_freq + sec_freq) / 2 + 40;
370 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz",
371 affected_start, affected_end);
372
373 mode = iface->current_mode;
374 params->freqs = os_calloc(mode->num_channels + 1, sizeof(int));
375 if (params->freqs == NULL)
376 return;
377 pos = 0;
378
379 for (i = 0; i < mode->num_channels; i++) {
380 struct hostapd_channel_data *chan = &mode->channels[i];
381 if (chan->flag & HOSTAPD_CHAN_DISABLED)
382 continue;
383 if (chan->freq < affected_start ||
384 chan->freq > affected_end)
385 continue;
386 params->freqs[pos++] = chan->freq;
387 }
388 }
389
390
ieee80211n_scan_channels_5g(struct hostapd_iface * iface,struct wpa_driver_scan_params * params)391 static void ieee80211n_scan_channels_5g(struct hostapd_iface *iface,
392 struct wpa_driver_scan_params *params)
393 {
394 /* Scan only the affected frequency range */
395 int pri_freq;
396 int affected_start, affected_end;
397 int i, pos;
398 struct hostapd_hw_modes *mode;
399
400 if (iface->current_mode == NULL)
401 return;
402
403 pri_freq = hostapd_hw_get_freq(iface->bss[0], iface->conf->channel);
404 if (iface->conf->secondary_channel > 0) {
405 affected_start = pri_freq - 10;
406 affected_end = pri_freq + 30;
407 } else {
408 affected_start = pri_freq - 30;
409 affected_end = pri_freq + 10;
410 }
411 wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz",
412 affected_start, affected_end);
413
414 mode = iface->current_mode;
415 params->freqs = os_calloc(mode->num_channels + 1, sizeof(int));
416 if (params->freqs == NULL)
417 return;
418 pos = 0;
419
420 for (i = 0; i < mode->num_channels; i++) {
421 struct hostapd_channel_data *chan = &mode->channels[i];
422 if (chan->flag & HOSTAPD_CHAN_DISABLED)
423 continue;
424 if (chan->freq < affected_start ||
425 chan->freq > affected_end)
426 continue;
427 params->freqs[pos++] = chan->freq;
428 }
429 }
430
431
ap_ht40_scan_retry(void * eloop_data,void * user_data)432 static void ap_ht40_scan_retry(void *eloop_data, void *user_data)
433 {
434 #define HT2040_COEX_SCAN_RETRY 15
435 struct hostapd_iface *iface = eloop_data;
436 struct wpa_driver_scan_params params;
437 int ret;
438
439 os_memset(¶ms, 0, sizeof(params));
440 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G)
441 ieee80211n_scan_channels_2g4(iface, ¶ms);
442 else
443 ieee80211n_scan_channels_5g(iface, ¶ms);
444
445 ret = hostapd_driver_scan(iface->bss[0], ¶ms);
446 iface->num_ht40_scan_tries++;
447 os_free(params.freqs);
448
449 if (ret == -EBUSY &&
450 iface->num_ht40_scan_tries < HT2040_COEX_SCAN_RETRY) {
451 wpa_printf(MSG_ERROR,
452 "Failed to request a scan of neighboring BSSes ret=%d (%s) - try to scan again (attempt %d)",
453 ret, strerror(-ret), iface->num_ht40_scan_tries);
454 eloop_register_timeout(1, 0, ap_ht40_scan_retry, iface, NULL);
455 return;
456 }
457
458 if (ret == 0) {
459 iface->scan_cb = ieee80211n_check_scan;
460 return;
461 }
462
463 wpa_printf(MSG_DEBUG,
464 "Failed to request a scan in device, bringing up in HT20 mode");
465 iface->conf->secondary_channel = 0;
466 iface->conf->ht_capab &= ~HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET;
467 hostapd_setup_interface_complete(iface, 0);
468 }
469
470
hostapd_stop_setup_timers(struct hostapd_iface * iface)471 void hostapd_stop_setup_timers(struct hostapd_iface *iface)
472 {
473 eloop_cancel_timeout(ap_ht40_scan_retry, iface, NULL);
474 }
475
476
ieee80211n_check_40mhz(struct hostapd_iface * iface)477 static int ieee80211n_check_40mhz(struct hostapd_iface *iface)
478 {
479 struct wpa_driver_scan_params params;
480 int ret;
481
482 /* Check that HT40 is used and PRI / SEC switch is allowed */
483 if (!iface->conf->secondary_channel || iface->conf->no_pri_sec_switch)
484 return 0;
485
486 hostapd_set_state(iface, HAPD_IFACE_HT_SCAN);
487 wpa_printf(MSG_DEBUG, "Scan for neighboring BSSes prior to enabling "
488 "40 MHz channel");
489 os_memset(¶ms, 0, sizeof(params));
490 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G)
491 ieee80211n_scan_channels_2g4(iface, ¶ms);
492 else
493 ieee80211n_scan_channels_5g(iface, ¶ms);
494
495 ret = hostapd_driver_scan(iface->bss[0], ¶ms);
496 os_free(params.freqs);
497
498 if (ret == -EBUSY) {
499 wpa_printf(MSG_ERROR,
500 "Failed to request a scan of neighboring BSSes ret=%d (%s) - try to scan again",
501 ret, strerror(-ret));
502 iface->num_ht40_scan_tries = 1;
503 eloop_cancel_timeout(ap_ht40_scan_retry, iface, NULL);
504 eloop_register_timeout(1, 0, ap_ht40_scan_retry, iface, NULL);
505 return 1;
506 }
507
508 if (ret < 0) {
509 wpa_printf(MSG_ERROR,
510 "Failed to request a scan of neighboring BSSes ret=%d (%s)",
511 ret, strerror(-ret));
512 return -1;
513 }
514
515 iface->scan_cb = ieee80211n_check_scan;
516 return 1;
517 }
518
519
ieee80211n_supported_ht_capab(struct hostapd_iface * iface)520 static int ieee80211n_supported_ht_capab(struct hostapd_iface *iface)
521 {
522 u16 hw = iface->current_mode->ht_capab;
523 u16 conf = iface->conf->ht_capab;
524
525 if ((conf & HT_CAP_INFO_LDPC_CODING_CAP) &&
526 !(hw & HT_CAP_INFO_LDPC_CODING_CAP)) {
527 wpa_printf(MSG_ERROR, "Driver does not support configured "
528 "HT capability [LDPC]");
529 return 0;
530 }
531
532 /*
533 * Driver ACS chosen channel may not be HT40 due to internal driver
534 * restrictions.
535 */
536 if (!iface->conf->acs && (conf & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET) &&
537 !(hw & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) {
538 wpa_printf(MSG_ERROR, "Driver does not support configured "
539 "HT capability [HT40*]");
540 return 0;
541 }
542
543 switch (conf & HT_CAP_INFO_SMPS_MASK) {
544 case HT_CAP_INFO_SMPS_STATIC:
545 if (!(iface->smps_modes & WPA_DRIVER_SMPS_MODE_STATIC)) {
546 wpa_printf(MSG_ERROR,
547 "Driver does not support configured HT capability [SMPS-STATIC]");
548 return 0;
549 }
550 break;
551 case HT_CAP_INFO_SMPS_DYNAMIC:
552 if (!(iface->smps_modes & WPA_DRIVER_SMPS_MODE_DYNAMIC)) {
553 wpa_printf(MSG_ERROR,
554 "Driver does not support configured HT capability [SMPS-DYNAMIC]");
555 return 0;
556 }
557 break;
558 case HT_CAP_INFO_SMPS_DISABLED:
559 default:
560 break;
561 }
562
563 if ((conf & HT_CAP_INFO_GREEN_FIELD) &&
564 !(hw & HT_CAP_INFO_GREEN_FIELD)) {
565 wpa_printf(MSG_ERROR, "Driver does not support configured "
566 "HT capability [GF]");
567 return 0;
568 }
569
570 if ((conf & HT_CAP_INFO_SHORT_GI20MHZ) &&
571 !(hw & HT_CAP_INFO_SHORT_GI20MHZ)) {
572 wpa_printf(MSG_ERROR, "Driver does not support configured "
573 "HT capability [SHORT-GI-20]");
574 return 0;
575 }
576
577 if ((conf & HT_CAP_INFO_SHORT_GI40MHZ) &&
578 !(hw & HT_CAP_INFO_SHORT_GI40MHZ)) {
579 wpa_printf(MSG_ERROR, "Driver does not support configured "
580 "HT capability [SHORT-GI-40]");
581 return 0;
582 }
583
584 if ((conf & HT_CAP_INFO_TX_STBC) && !(hw & HT_CAP_INFO_TX_STBC)) {
585 wpa_printf(MSG_ERROR, "Driver does not support configured "
586 "HT capability [TX-STBC]");
587 return 0;
588 }
589
590 if ((conf & HT_CAP_INFO_RX_STBC_MASK) >
591 (hw & HT_CAP_INFO_RX_STBC_MASK)) {
592 wpa_printf(MSG_ERROR, "Driver does not support configured "
593 "HT capability [RX-STBC*]");
594 return 0;
595 }
596
597 if ((conf & HT_CAP_INFO_DELAYED_BA) &&
598 !(hw & HT_CAP_INFO_DELAYED_BA)) {
599 wpa_printf(MSG_ERROR, "Driver does not support configured "
600 "HT capability [DELAYED-BA]");
601 return 0;
602 }
603
604 if ((conf & HT_CAP_INFO_MAX_AMSDU_SIZE) &&
605 !(hw & HT_CAP_INFO_MAX_AMSDU_SIZE)) {
606 wpa_printf(MSG_ERROR, "Driver does not support configured "
607 "HT capability [MAX-AMSDU-7935]");
608 return 0;
609 }
610
611 if ((conf & HT_CAP_INFO_DSSS_CCK40MHZ) &&
612 !(hw & HT_CAP_INFO_DSSS_CCK40MHZ)) {
613 wpa_printf(MSG_ERROR, "Driver does not support configured "
614 "HT capability [DSSS_CCK-40]");
615 return 0;
616 }
617
618 if ((conf & HT_CAP_INFO_LSIG_TXOP_PROTECT_SUPPORT) &&
619 !(hw & HT_CAP_INFO_LSIG_TXOP_PROTECT_SUPPORT)) {
620 wpa_printf(MSG_ERROR, "Driver does not support configured "
621 "HT capability [LSIG-TXOP-PROT]");
622 return 0;
623 }
624
625 return 1;
626 }
627
628
629 #ifdef CONFIG_IEEE80211AC
ieee80211ac_supported_vht_capab(struct hostapd_iface * iface)630 static int ieee80211ac_supported_vht_capab(struct hostapd_iface *iface)
631 {
632 struct hostapd_hw_modes *mode = iface->current_mode;
633 u32 hw = mode->vht_capab;
634 u32 conf = iface->conf->vht_capab;
635
636 wpa_printf(MSG_DEBUG, "hw vht capab: 0x%x, conf vht capab: 0x%x",
637 hw, conf);
638
639 if (mode->mode == HOSTAPD_MODE_IEEE80211G &&
640 iface->conf->bss[0]->vendor_vht &&
641 mode->vht_capab == 0 && iface->hw_features) {
642 int i;
643
644 for (i = 0; i < iface->num_hw_features; i++) {
645 if (iface->hw_features[i].mode ==
646 HOSTAPD_MODE_IEEE80211A) {
647 mode = &iface->hw_features[i];
648 hw = mode->vht_capab;
649 wpa_printf(MSG_DEBUG,
650 "update hw vht capab based on 5 GHz band: 0x%x",
651 hw);
652 break;
653 }
654 }
655 }
656
657 return ieee80211ac_cap_check(hw, conf);
658 }
659 #endif /* CONFIG_IEEE80211AC */
660
661 #endif /* CONFIG_IEEE80211N */
662
663
hostapd_check_ht_capab(struct hostapd_iface * iface)664 int hostapd_check_ht_capab(struct hostapd_iface *iface)
665 {
666 #ifdef CONFIG_IEEE80211N
667 int ret;
668 if (!iface->conf->ieee80211n)
669 return 0;
670
671 if (iface->current_mode->mode != HOSTAPD_MODE_IEEE80211B &&
672 iface->current_mode->mode != HOSTAPD_MODE_IEEE80211G &&
673 (iface->conf->ht_capab & HT_CAP_INFO_DSSS_CCK40MHZ)) {
674 wpa_printf(MSG_DEBUG,
675 "Disable HT capability [DSSS_CCK-40] on 5 GHz band");
676 iface->conf->ht_capab &= ~HT_CAP_INFO_DSSS_CCK40MHZ;
677 }
678
679 if (!ieee80211n_supported_ht_capab(iface))
680 return -1;
681 #ifdef CONFIG_IEEE80211AC
682 if (!ieee80211ac_supported_vht_capab(iface))
683 return -1;
684 #endif /* CONFIG_IEEE80211AC */
685 ret = ieee80211n_check_40mhz(iface);
686 if (ret)
687 return ret;
688 if (!ieee80211n_allowed_ht40_channel_pair(iface))
689 return -1;
690 #endif /* CONFIG_IEEE80211N */
691
692 return 0;
693 }
694
695
hostapd_is_usable_chan(struct hostapd_iface * iface,int channel,int primary)696 static int hostapd_is_usable_chan(struct hostapd_iface *iface,
697 int channel, int primary)
698 {
699 int i;
700 struct hostapd_channel_data *chan;
701
702 if (!iface->current_mode)
703 return 0;
704
705 for (i = 0; i < iface->current_mode->num_channels; i++) {
706 chan = &iface->current_mode->channels[i];
707 if (chan->chan != channel)
708 continue;
709
710 if (!(chan->flag & HOSTAPD_CHAN_DISABLED))
711 return 1;
712
713 wpa_printf(MSG_DEBUG,
714 "%schannel [%i] (%i) is disabled for use in AP mode, flags: 0x%x%s%s",
715 primary ? "" : "Configured HT40 secondary ",
716 i, chan->chan, chan->flag,
717 chan->flag & HOSTAPD_CHAN_NO_IR ? " NO-IR" : "",
718 chan->flag & HOSTAPD_CHAN_RADAR ? " RADAR" : "");
719 }
720
721 wpa_printf(MSG_INFO, "Channel %d (%s) not allowed for AP mode",
722 channel, primary ? "primary" : "secondary");
723 return 0;
724 }
725
726
hostapd_is_usable_chans(struct hostapd_iface * iface)727 static int hostapd_is_usable_chans(struct hostapd_iface *iface)
728 {
729 int secondary_chan;
730
731 if (!hostapd_is_usable_chan(iface, iface->conf->channel, 1))
732 return 0;
733
734 if (!iface->conf->secondary_channel)
735 return 1;
736
737 if (!iface->conf->ht40_plus_minus_allowed)
738 return hostapd_is_usable_chan(
739 iface, iface->conf->channel +
740 iface->conf->secondary_channel * 4, 0);
741
742 /* Both HT40+ and HT40- are set, pick a valid secondary channel */
743 secondary_chan = iface->conf->channel + 4;
744 if (hostapd_is_usable_chan(iface, secondary_chan, 0)) {
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 iface->conf->secondary_channel = -1;
752 return 1;
753 }
754
755 return 0;
756 }
757
758
759 static enum hostapd_chan_status
hostapd_check_chans(struct hostapd_iface * iface)760 hostapd_check_chans(struct hostapd_iface *iface)
761 {
762 if (iface->conf->channel) {
763 if (hostapd_is_usable_chans(iface))
764 return HOSTAPD_CHAN_VALID;
765 else
766 return HOSTAPD_CHAN_INVALID;
767 }
768
769 /*
770 * The user set channel=0 or channel=acs_survey
771 * which is used to trigger ACS.
772 */
773
774 switch (acs_init(iface)) {
775 case HOSTAPD_CHAN_ACS:
776 return HOSTAPD_CHAN_ACS;
777 case HOSTAPD_CHAN_VALID:
778 case HOSTAPD_CHAN_INVALID:
779 default:
780 return HOSTAPD_CHAN_INVALID;
781 }
782 }
783
784
hostapd_notify_bad_chans(struct hostapd_iface * iface)785 static void hostapd_notify_bad_chans(struct hostapd_iface *iface)
786 {
787 if (!iface->current_mode) {
788 hostapd_logger(iface->bss[0], NULL, HOSTAPD_MODULE_IEEE80211,
789 HOSTAPD_LEVEL_WARNING,
790 "Hardware does not support configured mode");
791 return;
792 }
793 hostapd_logger(iface->bss[0], NULL,
794 HOSTAPD_MODULE_IEEE80211,
795 HOSTAPD_LEVEL_WARNING,
796 "Configured channel (%d) not found from the "
797 "channel list of current mode (%d) %s",
798 iface->conf->channel,
799 iface->current_mode->mode,
800 hostapd_hw_mode_txt(iface->current_mode->mode));
801 hostapd_logger(iface->bss[0], NULL, HOSTAPD_MODULE_IEEE80211,
802 HOSTAPD_LEVEL_WARNING,
803 "Hardware does not support configured channel");
804 }
805
806
hostapd_acs_completed(struct hostapd_iface * iface,int err)807 int hostapd_acs_completed(struct hostapd_iface *iface, int err)
808 {
809 int ret = -1;
810
811 if (err)
812 goto out;
813
814 switch (hostapd_check_chans(iface)) {
815 case HOSTAPD_CHAN_VALID:
816 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO,
817 ACS_EVENT_COMPLETED "freq=%d channel=%d",
818 hostapd_hw_get_freq(iface->bss[0],
819 iface->conf->channel),
820 iface->conf->channel);
821 break;
822 case HOSTAPD_CHAN_ACS:
823 wpa_printf(MSG_ERROR, "ACS error - reported complete, but no result available");
824 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_FAILED);
825 hostapd_notify_bad_chans(iface);
826 goto out;
827 case HOSTAPD_CHAN_INVALID:
828 default:
829 wpa_printf(MSG_ERROR, "ACS picked unusable channels");
830 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_FAILED);
831 hostapd_notify_bad_chans(iface);
832 goto out;
833 }
834
835 ret = hostapd_check_ht_capab(iface);
836 if (ret < 0)
837 goto out;
838 if (ret == 1) {
839 wpa_printf(MSG_DEBUG, "Interface initialization will be completed in a callback");
840 return 0;
841 }
842
843 ret = 0;
844 out:
845 return hostapd_setup_interface_complete(iface, ret);
846 }
847
848
849 /**
850 * hostapd_select_hw_mode - Select the hardware mode
851 * @iface: Pointer to interface data.
852 * Returns: 0 on success, < 0 on failure
853 *
854 * Sets up the hardware mode, channel, rates, and passive scanning
855 * based on the configuration.
856 */
hostapd_select_hw_mode(struct hostapd_iface * iface)857 int hostapd_select_hw_mode(struct hostapd_iface *iface)
858 {
859 int i;
860
861 if (iface->num_hw_features < 1)
862 return -1;
863
864 if ((iface->conf->hw_mode == HOSTAPD_MODE_IEEE80211G ||
865 iface->conf->ieee80211n || iface->conf->ieee80211ac) &&
866 iface->conf->channel == 14) {
867 wpa_printf(MSG_INFO, "Disable OFDM/HT/VHT on channel 14");
868 iface->conf->hw_mode = HOSTAPD_MODE_IEEE80211B;
869 iface->conf->ieee80211n = 0;
870 iface->conf->ieee80211ac = 0;
871 }
872
873 iface->current_mode = NULL;
874 for (i = 0; i < iface->num_hw_features; i++) {
875 struct hostapd_hw_modes *mode = &iface->hw_features[i];
876 if (mode->mode == iface->conf->hw_mode) {
877 iface->current_mode = mode;
878 break;
879 }
880 }
881
882 if (iface->current_mode == NULL) {
883 if (!(iface->drv_flags & WPA_DRIVER_FLAGS_ACS_OFFLOAD) ||
884 !(iface->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_HW_MODE_ANY))
885 {
886 wpa_printf(MSG_ERROR,
887 "Hardware does not support configured mode");
888 hostapd_logger(iface->bss[0], NULL,
889 HOSTAPD_MODULE_IEEE80211,
890 HOSTAPD_LEVEL_WARNING,
891 "Hardware does not support configured mode (%d) (hw_mode in hostapd.conf)",
892 (int) iface->conf->hw_mode);
893 return -2;
894 }
895 }
896
897 switch (hostapd_check_chans(iface)) {
898 case HOSTAPD_CHAN_VALID:
899 return 0;
900 case HOSTAPD_CHAN_ACS: /* ACS will run and later complete */
901 return 1;
902 case HOSTAPD_CHAN_INVALID:
903 default:
904 hostapd_notify_bad_chans(iface);
905 return -3;
906 }
907 }
908
909
hostapd_hw_mode_txt(int mode)910 const char * hostapd_hw_mode_txt(int mode)
911 {
912 switch (mode) {
913 case HOSTAPD_MODE_IEEE80211A:
914 return "IEEE 802.11a";
915 case HOSTAPD_MODE_IEEE80211B:
916 return "IEEE 802.11b";
917 case HOSTAPD_MODE_IEEE80211G:
918 return "IEEE 802.11g";
919 case HOSTAPD_MODE_IEEE80211AD:
920 return "IEEE 802.11ad";
921 default:
922 return "UNKNOWN";
923 }
924 }
925
926
hostapd_hw_get_freq(struct hostapd_data * hapd,int chan)927 int hostapd_hw_get_freq(struct hostapd_data *hapd, int chan)
928 {
929 return hw_get_freq(hapd->iface->current_mode, chan);
930 }
931
932
hostapd_hw_get_channel(struct hostapd_data * hapd,int freq)933 int hostapd_hw_get_channel(struct hostapd_data *hapd, int freq)
934 {
935 int i, channel;
936 struct hostapd_hw_modes *mode;
937
938 channel = hw_get_chan(hapd->iface->current_mode, freq);
939 if (channel)
940 return channel;
941 /* Check other available modes since the channel list for the current
942 * mode did not include the specified frequency. */
943 for (i = 0; i < hapd->iface->num_hw_features; i++) {
944 mode = &hapd->iface->hw_features[i];
945 channel = hw_get_chan(mode, freq);
946 if (channel)
947 return channel;
948 }
949 return 0;
950 }
951