]> git.ipfire.org Git - thirdparty/hostap.git/blame - src/ap/acs.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ACS: Stop before scan if no channels in chanlist are available
[thirdparty/hostap.git] / src / ap / acs.c
CommitLineData
50f4f2a0
MK		 1/*
2 * ACS - Automatic Channel Selection module
3 * Copyright (c) 2011, Atheros Communications
4 * Copyright (c) 2013, 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 "utils/includes.h"
11#include <math.h>
12
13#include "utils/common.h"
14#include "utils/list.h"
15#include "common/ieee802_11_defs.h"
75ce63e0 16#include "common/hw_features_common.h"
ae134e1d 17#include "common/wpa_ctrl.h"
50f4f2a0
MK		 18#include "drivers/driver.h"
19#include "hostapd.h"
20#include "ap_drv_ops.h"
21#include "ap_config.h"
22#include "hw_features.h"
23#include "acs.h"
24
25/*
26 * Automatic Channel Selection
27 * ===========================
28 *
29 * More info at
30 * ------------
31 * http://wireless.kernel.org/en/users/Documentation/acs
32 *
33 * How to use
34 * ----------
35 * - make sure you have CONFIG_ACS=y in hostapd's .config
36 * - use channel=0 or channel=acs to enable ACS
37 *
38 * How does it work
39 * ----------------
40 * 1. passive scans are used to collect survey data
41 * (it is assumed that scan trigger collection of survey data in driver)
42 * 2. interference factor is calculated for each channel
43 * 3. ideal channel is picked depending on channel width by using adjacent
44 * channel interference factors
45 *
46 * Known limitations
47 * -----------------
48 * - Current implementation depends heavily on the amount of time willing to
49 * spend gathering survey data during hostapd startup. Short traffic bursts
50 * may be missed and a suboptimal channel may be picked.
51 * - Ideal channel may end up overlapping a channel with 40 MHz intolerant BSS
52 *
53 * Todo / Ideas
54 * ------------
55 * - implement other interference computation methods
56 * - BSS/RSSI based
57 * - spectral scan based
58 * (should be possibly to hook this up with current ACS scans)
59 * - add wpa_supplicant support (for P2P)
60 * - collect a histogram of interference over time allowing more educated
61 * guess about an ideal channel (perhaps CSA could be used to migrate AP to a
62 * new "better" channel while running)
63 * - include neighboring BSS scan to avoid conflicts with 40 MHz intolerant BSSs
64 * when choosing the ideal channel
65 *
66 * Survey interference factor implementation details
67 * -------------------------------------------------
68 * Generic interference_factor in struct hostapd_channel_data is used.
69 *
70 * The survey interference factor is defined as the ratio of the
71 * observed busy time over the time we spent on the channel,
72 * this value is then amplified by the observed noise floor on
73 * the channel in comparison to the lowest noise floor observed
74 * on the entire band.
75 *
76 * This corresponds to:
77 * ---
78 * (busy time - tx time) / (active time - tx time) * 2^(chan_nf + band_min_nf)
79 * ---
80 *
81 * The coefficient of 2 reflects the way power in "far-field"
82 * radiation decreases as the square of distance from the antenna [1].
83 * What this does is it decreases the observed busy time ratio if the
84 * noise observed was low but increases it if the noise was high,
85 * proportionally to the way "far field" radiation changes over
86 * distance.
87 *
88 * If channel busy time is not available the fallback is to use channel RX time.
89 *
90 * Since noise floor is in dBm it is necessary to convert it into Watts so that
91 * combined channel interference (e.g., HT40, which uses two channels) can be
92 * calculated easily.
93 * ---
94 * (busy time - tx time) / (active time - tx time) *
95 * 2^(10^(chan_nf/10) + 10^(band_min_nf/10))
96 * ---
97 *
98 * However to account for cases where busy/rx time is 0 (channel load is then
99 * 0%) channel noise floor signal power is combined into the equation so a
100 * channel with lower noise floor is preferred. The equation becomes:
101 * ---
102 * 10^(chan_nf/5) + (busy time - tx time) / (active time - tx time) *
103 * 2^(10^(chan_nf/10) + 10^(band_min_nf/10))
104 * ---
105 *
106 * All this "interference factor" is purely subjective and only time
107 * will tell how usable this is. By using the minimum noise floor we
108 * remove any possible issues due to card calibration. The computation
109 * of the interference factor then is dependent on what the card itself
110 * picks up as the minimum noise, not an actual real possible card
111 * noise value.
112 *
113 * Total interference computation details
114 * --------------------------------------
115 * The above channel interference factor is calculated with no respect to
116 * target operational bandwidth.
117 *
118 * To find an ideal channel the above data is combined by taking into account
119 * the target operational bandwidth and selected band. E.g., on 2.4 GHz channels
120 * overlap with 20 MHz bandwidth, but there is no overlap for 20 MHz bandwidth
121 * on 5 GHz.
122 *
123 * Each valid and possible channel spec (i.e., channel + width) is taken and its
124 * interference factor is computed by summing up interferences of each channel
125 * it overlaps. The one with least total interference is picked up.
126 *
127 * Note: This implies base channel interference factor must be non-negative
128 * allowing easy summing up.
129 *
130 * Example ACS analysis printout
131 * -----------------------------
132 *
133 * ACS: Trying survey-based ACS
134 * ACS: Survey analysis for channel 1 (2412 MHz)
135 * ACS: 1: min_nf=-113 interference_factor=0.0802469 nf=-113 time=162 busy=0 rx=13
136 * ACS: 2: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
137 * ACS: 3: min_nf=-113 interference_factor=0.0679012 nf=-113 time=162 busy=0 rx=11
138 * ACS: 4: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
139 * ACS: 5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
140 * ACS: * interference factor average: 0.0557166
141 * ACS: Survey analysis for channel 2 (2417 MHz)
142 * ACS: 1: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
143 * ACS: 2: min_nf=-113 interference_factor=0.0246914 nf=-113 time=162 busy=0 rx=4
144 * ACS: 3: min_nf=-113 interference_factor=0.037037 nf=-113 time=162 busy=0 rx=6
145 * ACS: 4: min_nf=-113 interference_factor=0.149068 nf=-113 time=161 busy=0 rx=24
146 * ACS: 5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
147 * ACS: * interference factor average: 0.050832
148 * ACS: Survey analysis for channel 3 (2422 MHz)
149 * ACS: 1: min_nf=-113 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
150 * ACS: 2: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
151 * ACS: 3: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
152 * ACS: 4: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
153 * ACS: 5: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
154 * ACS: * interference factor average: 0.0148838
155 * ACS: Survey analysis for channel 4 (2427 MHz)
156 * ACS: 1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
157 * ACS: 2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
158 * ACS: 3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
159 * ACS: 4: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
160 * ACS: 5: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
161 * ACS: * interference factor average: 0.0160801
162 * ACS: Survey analysis for channel 5 (2432 MHz)
163 * ACS: 1: min_nf=-114 interference_factor=0.409938 nf=-113 time=161 busy=0 rx=66
164 * ACS: 2: min_nf=-114 interference_factor=0.0432099 nf=-113 time=162 busy=0 rx=7
165 * ACS: 3: min_nf=-114 interference_factor=0.0124224 nf=-113 time=161 busy=0 rx=2
166 * ACS: 4: min_nf=-114 interference_factor=0.677019 nf=-113 time=161 busy=0 rx=109
167 * ACS: 5: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
168 * ACS: * interference factor average: 0.232244
169 * ACS: Survey analysis for channel 6 (2437 MHz)
170 * ACS: 1: min_nf=-113 interference_factor=0.552795 nf=-113 time=161 busy=0 rx=89
171 * ACS: 2: min_nf=-113 interference_factor=0.0807453 nf=-112 time=161 busy=0 rx=13
172 * ACS: 3: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
173 * ACS: 4: min_nf=-113 interference_factor=0.434783 nf=-112 time=161 busy=0 rx=70
174 * ACS: 5: min_nf=-113 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
175 * ACS: * interference factor average: 0.232298
176 * ACS: Survey analysis for channel 7 (2442 MHz)
177 * ACS: 1: min_nf=-113 interference_factor=0.440994 nf=-112 time=161 busy=0 rx=71
178 * ACS: 2: min_nf=-113 interference_factor=0.385093 nf=-113 time=161 busy=0 rx=62
179 * ACS: 3: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
180 * ACS: 4: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
181 * ACS: 5: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
182 * ACS: * interference factor average: 0.195031
183 * ACS: Survey analysis for channel 8 (2447 MHz)
184 * ACS: 1: min_nf=-114 interference_factor=0.0496894 nf=-112 time=161 busy=0 rx=8
185 * ACS: 2: min_nf=-114 interference_factor=0.0496894 nf=-114 time=161 busy=0 rx=8
186 * ACS: 3: min_nf=-114 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
187 * ACS: 4: min_nf=-114 interference_factor=0.12963 nf=-113 time=162 busy=0 rx=21
188 * ACS: 5: min_nf=-114 interference_factor=0.166667 nf=-114 time=162 busy=0 rx=27
189 * ACS: * interference factor average: 0.0865885
190 * ACS: Survey analysis for channel 9 (2452 MHz)
191 * ACS: 1: min_nf=-114 interference_factor=0.0124224 nf=-114 time=161 busy=0 rx=2
192 * ACS: 2: min_nf=-114 interference_factor=0.0310559 nf=-114 time=161 busy=0 rx=5
193 * ACS: 3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
194 * ACS: 4: min_nf=-114 interference_factor=0.00617284 nf=-114 time=162 busy=0 rx=1
195 * ACS: 5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
196 * ACS: * interference factor average: 0.00993022
197 * ACS: Survey analysis for channel 10 (2457 MHz)
198 * ACS: 1: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
199 * ACS: 2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
200 * ACS: 3: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
201 * ACS: 4: min_nf=-114 interference_factor=0.0493827 nf=-114 time=162 busy=0 rx=8
202 * ACS: 5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
203 * ACS: * interference factor average: 0.0136033
204 * ACS: Survey analysis for channel 11 (2462 MHz)
205 * ACS: 1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
206 * ACS: 2: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
207 * ACS: 3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
208 * ACS: 4: min_nf=-114 interference_factor=0.0432099 nf=-114 time=162 busy=0 rx=7
209 * ACS: 5: min_nf=-114 interference_factor=0.0925926 nf=-114 time=162 busy=0 rx=15
210 * ACS: * interference factor average: 0.0271605
211 * ACS: Survey analysis for channel 12 (2467 MHz)
212 * ACS: 1: min_nf=-114 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
213 * ACS: 2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
214 * ACS: 3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
215 * ACS: 4: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
216 * ACS: 5: min_nf=-114 interference_factor=0.00617284 nf=-113 time=162 busy=0 rx=1
217 * ACS: * interference factor average: 0.0148992
218 * ACS: Survey analysis for channel 13 (2472 MHz)
219 * ACS: 1: min_nf=-114 interference_factor=0.0745342 nf=-114 time=161 busy=0 rx=12
220 * ACS: 2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
221 * ACS: 3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
222 * ACS: 4: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
223 * ACS: 5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
224 * ACS: * interference factor average: 0.0260179
225 * ACS: Survey analysis for selected bandwidth 20MHz
226 * ACS: * channel 1: total interference = 0.121432
227 * ACS: * channel 2: total interference = 0.137512
228 * ACS: * channel 3: total interference = 0.369757
229 * ACS: * channel 4: total interference = 0.546338
230 * ACS: * channel 5: total interference = 0.690538
231 * ACS: * channel 6: total interference = 0.762242
232 * ACS: * channel 7: total interference = 0.756092
233 * ACS: * channel 8: total interference = 0.537451
234 * ACS: * channel 9: total interference = 0.332313
235 * ACS: * channel 10: total interference = 0.152182
236 * ACS: * channel 11: total interference = 0.0916111
237 * ACS: * channel 12: total interference = 0.0816809
238 * ACS: * channel 13: total interference = 0.0680776
239 * ACS: Ideal channel is 13 (2472 MHz) with total interference factor of 0.0680776
240 *
241 * [1] http://en.wikipedia.org/wiki/Near_and_far_field
242 */
243
244
245static int acs_request_scan(struct hostapd_iface *iface);
0d7eb434 246static int acs_survey_is_sufficient(struct freq_survey *survey);
50f4f2a0
MK		 247
248
249static void acs_clean_chan_surveys(struct hostapd_channel_data *chan)
250{
251 struct freq_survey *survey, *tmp;
252
253 if (dl_list_empty(&chan->survey_list))
254 return;
255
256 dl_list_for_each_safe(survey, tmp, &chan->survey_list,
257 struct freq_survey, list) {
258 dl_list_del(&survey->list);
259 os_free(survey);
260 }
261}
262
263
4c803dfc 264void acs_cleanup(struct hostapd_iface *iface)
50f4f2a0
MK		 265{
266 int i;
267 struct hostapd_channel_data *chan;
268
269 for (i = 0; i < iface->current_mode->num_channels; i++) {
270 chan = &iface->current_mode->channels[i];
271
272 if (chan->flag & HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED)
273 acs_clean_chan_surveys(chan);
274
275 dl_list_init(&chan->survey_list);
276 chan->flag |= HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED;
277 chan->min_nf = 0;
278 }
279
280 iface->chans_surveyed = 0;
281 iface->acs_num_completed_scans = 0;
282}
283
284
f7fb6766 285static void acs_fail(struct hostapd_iface *iface)
50f4f2a0
MK		 286{
287 wpa_printf(MSG_ERROR, "ACS: Failed to start");
288 acs_cleanup(iface);
185677b7 289 hostapd_disable_iface(iface);
50f4f2a0
MK		 290}
291
292
293static long double
294acs_survey_interference_factor(struct freq_survey *survey, s8 min_nf)
295{
296 long double factor, busy, total;
297
298 if (survey->filled & SURVEY_HAS_CHAN_TIME_BUSY)
299 busy = survey->channel_time_busy;
300 else if (survey->filled & SURVEY_HAS_CHAN_TIME_RX)
301 busy = survey->channel_time_rx;
302 else {
303 /* This shouldn't really happen as survey data is checked in
304 * acs_sanity_check() */
305 wpa_printf(MSG_ERROR, "ACS: Survey data missing");
306 return 0;
307 }
308
309 total = survey->channel_time;
310
311 if (survey->filled & SURVEY_HAS_CHAN_TIME_TX) {
312 busy -= survey->channel_time_tx;
313 total -= survey->channel_time_tx;
314 }
315
316 /* TODO: figure out the best multiplier for noise floor base */
317 factor = pow(10, survey->nf / 5.0L) +
c4dd3afa 318 (total ? (busy / total) : 0) *
50f4f2a0
MK		 319 pow(2, pow(10, (long double) survey->nf / 10.0L) -
320 pow(10, (long double) min_nf / 10.0L));
321
322 return factor;
323}
324
325
326static void
327acs_survey_chan_interference_factor(struct hostapd_iface *iface,
328 struct hostapd_channel_data *chan)
329{
330 struct freq_survey *survey;
331 unsigned int i = 0;
332 long double int_factor = 0;
0d7eb434 333 unsigned count = 0;
50f4f2a0 334
29be2c09
JM		 335 if (dl_list_empty(&chan->survey_list) ||
336 (chan->flag & HOSTAPD_CHAN_DISABLED))
50f4f2a0
MK		 337 return;
338
339 chan->interference_factor = 0;
340
341 dl_list_for_each(survey, &chan->survey_list, struct freq_survey, list)
342 {
0d7eb434
JM		 343 i++;
344
345 if (!acs_survey_is_sufficient(survey)) {
346 wpa_printf(MSG_DEBUG, "ACS: %d: insufficient data", i);
347 continue;
348 }
349
350 count++;
50f4f2a0
MK		 351 int_factor = acs_survey_interference_factor(survey,
352 iface->lowest_nf);
353 chan->interference_factor += int_factor;
354 wpa_printf(MSG_DEBUG, "ACS: %d: min_nf=%d interference_factor=%Lg nf=%d time=%lu busy=%lu rx=%lu",
0d7eb434 355 i, chan->min_nf, int_factor,
50f4f2a0
MK		 356 survey->nf, (unsigned long) survey->channel_time,
357 (unsigned long) survey->channel_time_busy,
358 (unsigned long) survey->channel_time_rx);
359 }
360
29be2c09
JM		 361 if (count)
362 chan->interference_factor /= count;
50f4f2a0
MK		 363}
364
365
22dcafc2 366static int acs_usable_ht40_chan(const struct hostapd_channel_data *chan)
50f4f2a0
MK		 367{
368 const int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149,
369 157, 184, 192 };
370 unsigned int i;
371
e7ecab4a 372 for (i = 0; i < ARRAY_SIZE(allowed); i++)
50f4f2a0
MK		 373 if (chan->chan == allowed[i])
374 return 1;
375
376 return 0;
377}
378
379
22dcafc2 380static int acs_usable_vht80_chan(const struct hostapd_channel_data *chan)
89de64c5
MK		 381{
382 const int allowed[] = { 36, 52, 100, 116, 132, 149 };
383 unsigned int i;
384
385 for (i = 0; i < ARRAY_SIZE(allowed); i++)
386 if (chan->chan == allowed[i])
387 return 1;
388
389 return 0;
390}
391
392
22dcafc2
DL		 393static int acs_usable_vht160_chan(const struct hostapd_channel_data *chan)
394{
395 const int allowed[] = { 36, 100 };
396 unsigned int i;
397
398 for (i = 0; i < ARRAY_SIZE(allowed); i++)
399 if (chan->chan == allowed[i])
400 return 1;
401
402 return 0;
403}
404
405
50f4f2a0
MK		 406static int acs_survey_is_sufficient(struct freq_survey *survey)
407{
408 if (!(survey->filled & SURVEY_HAS_NF)) {
0d7eb434 409 wpa_printf(MSG_INFO, "ACS: Survey is missing noise floor");
50f4f2a0
MK		 410 return 0;
411 }
412
413 if (!(survey->filled & SURVEY_HAS_CHAN_TIME)) {
0d7eb434 414 wpa_printf(MSG_INFO, "ACS: Survey is missing channel time");
50f4f2a0
MK		 415 return 0;
416 }
417
418 if (!(survey->filled & SURVEY_HAS_CHAN_TIME_BUSY) &&
419 !(survey->filled & SURVEY_HAS_CHAN_TIME_RX)) {
0d7eb434
JM		 420 wpa_printf(MSG_INFO,
421 "ACS: Survey is missing RX and busy time (at least one is required)");
50f4f2a0
MK		 422 return 0;
423 }
424
425 return 1;
426}
427
428
20f9cb18
HS		 429static int acs_survey_list_is_sufficient(struct hostapd_channel_data *chan)
430{
431 struct freq_survey *survey;
0d7eb434 432 int ret = -1;
20f9cb18
HS		 433
434 dl_list_for_each(survey, &chan->survey_list, struct freq_survey, list)
435 {
0d7eb434
JM		 436 if (acs_survey_is_sufficient(survey)) {
437 ret = 1;
438 break;
20f9cb18 439 }
0d7eb434 440 ret = 0;
20f9cb18
HS		 441 }
442
0d7eb434
JM		 443 if (ret == -1)
444 ret = 1; /* no survey list entries */
445
446 if (!ret) {
447 wpa_printf(MSG_INFO,
448 "ACS: Channel %d has insufficient survey data",
449 chan->chan);
450 }
20f9cb18 451
0d7eb434 452 return ret;
20f9cb18
HS		 453}
454
455
50f4f2a0
MK		 456static int acs_surveys_are_sufficient(struct hostapd_iface *iface)
457{
458 int i;
459 struct hostapd_channel_data *chan;
20f9cb18 460 int valid = 0;
50f4f2a0
MK		 461
462 for (i = 0; i < iface->current_mode->num_channels; i++) {
463 chan = &iface->current_mode->channels[i];
29be2c09
JM		 464 if (!(chan->flag & HOSTAPD_CHAN_DISABLED) &&
465 acs_survey_list_is_sufficient(chan))
466 valid++;
50f4f2a0
MK		 467 }
468
20f9cb18
HS		 469 /* We need at least survey data for one channel */
470 return !!valid;
471}
472
473
474static int acs_usable_chan(struct hostapd_channel_data *chan)
475{
29be2c09
JM		 476 return !dl_list_empty(&chan->survey_list) &&
477 !(chan->flag & HOSTAPD_CHAN_DISABLED) &&
478 acs_survey_list_is_sufficient(chan);
50f4f2a0
MK		 479}
480
481
1648cc64
AD		 482static int is_in_chanlist(struct hostapd_iface *iface,
483 struct hostapd_channel_data *chan)
484{
857d9422 485 if (!iface->conf->acs_ch_list.num)
1648cc64
AD		 486 return 1;
487
857d9422 488 return freq_range_list_includes(&iface->conf->acs_ch_list, chan->chan);
1648cc64
AD		 489}
490
491
50f4f2a0
MK		 492static void acs_survey_all_chans_intereference_factor(
493 struct hostapd_iface *iface)
494{
495 int i;
496 struct hostapd_channel_data *chan;
497
498 for (i = 0; i < iface->current_mode->num_channels; i++) {
499 chan = &iface->current_mode->channels[i];
500
501 if (!acs_usable_chan(chan))
502 continue;
503
1648cc64
AD		 504 if (!is_in_chanlist(iface, chan))
505 continue;
506
50f4f2a0
MK		 507 wpa_printf(MSG_DEBUG, "ACS: Survey analysis for channel %d (%d MHz)",
508 chan->chan, chan->freq);
509
510 acs_survey_chan_interference_factor(iface, chan);
511
512 wpa_printf(MSG_DEBUG, "ACS: * interference factor average: %Lg",
513 chan->interference_factor);
514 }
515}
516
517
518static struct hostapd_channel_data *acs_find_chan(struct hostapd_iface *iface,
519 int freq)
520{
521 struct hostapd_channel_data *chan;
522 int i;
523
524 for (i = 0; i < iface->current_mode->num_channels; i++) {
525 chan = &iface->current_mode->channels[i];
526
677cf190 527 if (chan->flag & HOSTAPD_CHAN_DISABLED)
50f4f2a0
MK		 528 continue;
529
530 if (chan->freq == freq)
531 return chan;
532 }
533
534 return NULL;
535}
536
537
68fa00c3
JM		 538static int is_24ghz_mode(enum hostapd_hw_mode mode)
539{
540 return mode == HOSTAPD_MODE_IEEE80211B ||
541 mode == HOSTAPD_MODE_IEEE80211G;
542}
543
544
545static int is_common_24ghz_chan(int chan)
546{
547 return chan == 1 || chan == 6 || chan == 11;
548}
549
550
6f41a258
JM		 551#ifndef ACS_ADJ_WEIGHT
552#define ACS_ADJ_WEIGHT 0.85
553#endif /* ACS_ADJ_WEIGHT */
554
555#ifndef ACS_NEXT_ADJ_WEIGHT
556#define ACS_NEXT_ADJ_WEIGHT 0.55
557#endif /* ACS_NEXT_ADJ_WEIGHT */
558
68fa00c3
JM		 559#ifndef ACS_24GHZ_PREFER_1_6_11
560/*
561 * Select commonly used channels 1, 6, 11 by default even if a neighboring
562 * channel has a smaller interference factor as long as it is not better by more
563 * than this multiplier.
564 */
565#define ACS_24GHZ_PREFER_1_6_11 0.8
566#endif /* ACS_24GHZ_PREFER_1_6_11 */
567
50f4f2a0
MK		 568/*
569 * At this point it's assumed chan->interface_factor has been computed.
570 * This function should be reusable regardless of interference computation
571 * option (survey, BSS, spectral, ...). chan->interference factor must be
572 * summable (i.e., must be always greater than zero).
573 */
574static struct hostapd_channel_data *
575acs_find_ideal_chan(struct hostapd_iface *iface)
576{
677cf190
HS		 577 struct hostapd_channel_data *chan, *adj_chan, *ideal_chan = NULL,
578 *rand_chan = NULL;
50f4f2a0
MK		 579 long double factor, ideal_factor = 0;
580 int i, j;
581 int n_chans = 1;
75ce63e0 582 u32 bw;
68fa00c3 583 unsigned int k;
50f4f2a0
MK		 584
585 /* TODO: HT40- support */
586
587 if (iface->conf->ieee80211n &&
588 iface->conf->secondary_channel == -1) {
589 wpa_printf(MSG_ERROR, "ACS: HT40- is not supported yet. Please try HT40+");
590 return NULL;
591 }
592
593 if (iface->conf->ieee80211n &&
594 iface->conf->secondary_channel)
595 n_chans = 2;
596
1d2c45ec 597 if (iface->conf->ieee80211ac || iface->conf->ieee80211ax) {
c6b7ac07 598 switch (hostapd_get_oper_chwidth(iface->conf)) {
464dcfd0 599 case CHANWIDTH_80MHZ:
22dcafc2
DL		 600 n_chans = 4;
601 break;
464dcfd0 602 case CHANWIDTH_160MHZ:
22dcafc2
DL		 603 n_chans = 8;
604 break;
605 }
606 }
50f4f2a0 607
75ce63e0
DL		 608 bw = num_chan_to_bw(n_chans);
609
1d2c45ec 610 /* TODO: VHT/HE80+80. Update acs_adjust_center_freq() too. */
50f4f2a0 611
75ce63e0
DL		 612 wpa_printf(MSG_DEBUG,
613 "ACS: Survey analysis for selected bandwidth %d MHz", bw);
50f4f2a0
MK		 614
615 for (i = 0; i < iface->current_mode->num_channels; i++) {
6f41a258 616 double total_weight;
68fa00c3 617 struct acs_bias *bias, tmp_bias;
6f41a258 618
50f4f2a0
MK		 619 chan = &iface->current_mode->channels[i];
620
75ce63e0
DL		 621 /* Since in the current ACS implementation the first channel is
622 * always a primary channel, skip channels not available as
623 * primary until more sophisticated channel selection is
624 * implemented. */
625 if (!chan_pri_allowed(chan))
50f4f2a0
MK		 626 continue;
627
1648cc64
AD		 628 if (!is_in_chanlist(iface, chan))
629 continue;
677cf190 630
75ce63e0
DL		 631 if (!chan_bw_allowed(chan, bw, 1, 1)) {
632 wpa_printf(MSG_DEBUG,
633 "ACS: Channel %d: BW %u is not supported",
634 chan->chan, bw);
635 continue;
636 }
637
50f4f2a0
MK		 638 /* HT40 on 5 GHz has a limited set of primary channels as per
639 * 11n Annex J */
640 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A &&
641 iface->conf->ieee80211n &&
642 iface->conf->secondary_channel &&
643 !acs_usable_ht40_chan(chan)) {
644 wpa_printf(MSG_DEBUG, "ACS: Channel %d: not allowed as primary channel for HT40",
645 chan->chan);
646 continue;
647 }
648
89de64c5 649 if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A &&
1d2c45ec 650 (iface->conf->ieee80211ac || iface->conf->ieee80211ax)) {
c6b7ac07 651 if (hostapd_get_oper_chwidth(iface->conf) ==
464dcfd0 652 CHANWIDTH_80MHZ &&
22dcafc2
DL		 653 !acs_usable_vht80_chan(chan)) {
654 wpa_printf(MSG_DEBUG,
655 "ACS: Channel %d: not allowed as primary channel for VHT80",
656 chan->chan);
657 continue;
658 }
659
c6b7ac07 660 if (hostapd_get_oper_chwidth(iface->conf) ==
464dcfd0 661 CHANWIDTH_160MHZ &&
22dcafc2
DL		 662 !acs_usable_vht160_chan(chan)) {
663 wpa_printf(MSG_DEBUG,
664 "ACS: Channel %d: not allowed as primary channel for VHT160",
665 chan->chan);
666 continue;
667 }
89de64c5
MK		 668 }
669
677cf190
HS		 670 factor = 0;
671 if (acs_usable_chan(chan))
672 factor = chan->interference_factor;
6f41a258 673 total_weight = 1;
50f4f2a0
MK		 674
675 for (j = 1; j < n_chans; j++) {
676 adj_chan = acs_find_chan(iface, chan->freq + (j * 20));
677 if (!adj_chan)
678 break;
679
75ce63e0
DL		 680 if (!chan_bw_allowed(adj_chan, bw, 1, 0)) {
681 wpa_printf(MSG_DEBUG,
682 "ACS: PRI Channel %d: secondary channel %d BW %u is not supported",
683 chan->chan, adj_chan->chan, bw);
684 break;
685 }
686
6f41a258 687 if (acs_usable_chan(adj_chan)) {
677cf190 688 factor += adj_chan->interference_factor;
6f41a258
JM		 689 total_weight += 1;
690 }
50f4f2a0
MK		 691 }
692
693 if (j != n_chans) {
694 wpa_printf(MSG_DEBUG, "ACS: Channel %d: not enough bandwidth",
695 chan->chan);
696 continue;
697 }
698
699 /* 2.4 GHz has overlapping 20 MHz channels. Include adjacent
700 * channel interference factor. */
68fa00c3 701 if (is_24ghz_mode(iface->current_mode->mode)) {
50f4f2a0 702 for (j = 0; j < n_chans; j++) {
50f4f2a0
MK		 703 adj_chan = acs_find_chan(iface, chan->freq +
704 (j * 20) - 5);
6f41a258
JM		 705 if (adj_chan && acs_usable_chan(adj_chan)) {
706 factor += ACS_ADJ_WEIGHT *
707 adj_chan->interference_factor;
708 total_weight += ACS_ADJ_WEIGHT;
709 }
50f4f2a0
MK		 710
711 adj_chan = acs_find_chan(iface, chan->freq +
712 (j * 20) - 10);
6f41a258
JM		 713 if (adj_chan && acs_usable_chan(adj_chan)) {
714 factor += ACS_NEXT_ADJ_WEIGHT *
715 adj_chan->interference_factor;
716 total_weight += ACS_NEXT_ADJ_WEIGHT;
717 }
50f4f2a0
MK		 718
719 adj_chan = acs_find_chan(iface, chan->freq +
720 (j * 20) + 5);
6f41a258
JM		 721 if (adj_chan && acs_usable_chan(adj_chan)) {
722 factor += ACS_ADJ_WEIGHT *
723 adj_chan->interference_factor;
724 total_weight += ACS_ADJ_WEIGHT;
725 }
50f4f2a0
MK		 726
727 adj_chan = acs_find_chan(iface, chan->freq +
728 (j * 20) + 10);
6f41a258
JM		 729 if (adj_chan && acs_usable_chan(adj_chan)) {
730 factor += ACS_NEXT_ADJ_WEIGHT *
731 adj_chan->interference_factor;
732 total_weight += ACS_NEXT_ADJ_WEIGHT;
733 }
50f4f2a0
MK		 734 }
735 }
736
6f41a258
JM		 737 factor /= total_weight;
738
68fa00c3
JM		 739 bias = NULL;
740 if (iface->conf->acs_chan_bias) {
741 for (k = 0; k < iface->conf->num_acs_chan_bias; k++) {
742 bias = &iface->conf->acs_chan_bias[k];
743 if (bias->channel == chan->chan)
744 break;
745 bias = NULL;
746 }
747 } else if (is_24ghz_mode(iface->current_mode->mode) &&
748 is_common_24ghz_chan(chan->chan)) {
749 tmp_bias.channel = chan->chan;
750 tmp_bias.bias = ACS_24GHZ_PREFER_1_6_11;
751 bias = &tmp_bias;
752 }
753
754 if (bias) {
755 factor *= bias->bias;
756 wpa_printf(MSG_DEBUG,
757 "ACS: * channel %d: total interference = %Lg (%f bias)",
758 chan->chan, factor, bias->bias);
759 } else {
760 wpa_printf(MSG_DEBUG,
761 "ACS: * channel %d: total interference = %Lg",
762 chan->chan, factor);
763 }
50f4f2a0 764
677cf190
HS		 765 if (acs_usable_chan(chan) &&
766 (!ideal_chan || factor < ideal_factor)) {
50f4f2a0
MK		 767 ideal_factor = factor;
768 ideal_chan = chan;
769 }
677cf190
HS		 770
771 /* This channel would at least be usable */
772 if (!rand_chan)
773 rand_chan = chan;
50f4f2a0
MK		 774 }
775
677cf190 776 if (ideal_chan) {
50f4f2a0
MK		 777 wpa_printf(MSG_DEBUG, "ACS: Ideal channel is %d (%d MHz) with total interference factor of %Lg",
778 ideal_chan->chan, ideal_chan->freq, ideal_factor);
677cf190
HS		 779 return ideal_chan;
780 }
50f4f2a0 781
677cf190 782 return rand_chan;
50f4f2a0
MK		 783}
784
785
39b9d059 786static void acs_adjust_center_freq(struct hostapd_iface *iface)
50f4f2a0 787{
c3722e12
MK		 788 int offset;
789
50f4f2a0
MK		 790 wpa_printf(MSG_DEBUG, "ACS: Adjusting VHT center frequency");
791
c6b7ac07 792 switch (hostapd_get_oper_chwidth(iface->conf)) {
464dcfd0 793 case CHANWIDTH_USE_HT:
c3722e12 794 offset = 2 * iface->conf->secondary_channel;
50f4f2a0 795 break;
464dcfd0 796 case CHANWIDTH_80MHZ:
c3722e12 797 offset = 6;
50f4f2a0 798 break;
464dcfd0 799 case CHANWIDTH_160MHZ:
22dcafc2
DL		 800 offset = 14;
801 break;
50f4f2a0
MK		 802 default:
803 /* TODO: How can this be calculated? Adjust
804 * acs_find_ideal_chan() */
22dcafc2
DL		 805 wpa_printf(MSG_INFO,
806 "ACS: Only VHT20/40/80/160 is supported now");
c3722e12 807 return;
50f4f2a0 808 }
c3722e12 809
c6b7ac07
JC		 810 hostapd_set_oper_centr_freq_seg0_idx(iface->conf,
811 iface->conf->channel + offset);
50f4f2a0
MK		 812}
813
814
815static int acs_study_survey_based(struct hostapd_iface *iface)
816{
817 wpa_printf(MSG_DEBUG, "ACS: Trying survey-based ACS");
818
819 if (!iface->chans_surveyed) {
820 wpa_printf(MSG_ERROR, "ACS: Unable to collect survey data");
821 return -1;
822 }
823
824 if (!acs_surveys_are_sufficient(iface)) {
825 wpa_printf(MSG_ERROR, "ACS: Surveys have insufficient data");
826 return -1;
827 }
828
829 acs_survey_all_chans_intereference_factor(iface);
830 return 0;
831}
832
833
834static int acs_study_options(struct hostapd_iface *iface)
835{
29be2c09 836 if (acs_study_survey_based(iface) == 0)
50f4f2a0
MK		 837 return 0;
838
839 /* TODO: If no surveys are available/sufficient this is a good
840 * place to fallback to BSS-based ACS */
841
842 return -1;
843}
844
845
846static void acs_study(struct hostapd_iface *iface)
847{
848 struct hostapd_channel_data *ideal_chan;
849 int err;
850
851 err = acs_study_options(iface);
852 if (err < 0) {
853 wpa_printf(MSG_ERROR, "ACS: All study options have failed");
854 goto fail;
855 }
856
857 ideal_chan = acs_find_ideal_chan(iface);
858 if (!ideal_chan) {
859 wpa_printf(MSG_ERROR, "ACS: Failed to compute ideal channel");
3645fd5a 860 err = -1;
50f4f2a0
MK		 861 goto fail;
862 }
863
864 iface->conf->channel = ideal_chan->chan;
865
39b9d059
JC		 866 if (iface->conf->ieee80211ac || iface->conf->ieee80211ax)
867 acs_adjust_center_freq(iface);
50f4f2a0 868
3645fd5a
HS		 869 err = 0;
870fail:
50f4f2a0
MK		 871 /*
872 * hostapd_setup_interface_complete() will return -1 on failure,
873 * 0 on success and 0 is HOSTAPD_CHAN_VALID :)
874 */
3645fd5a 875 if (hostapd_acs_completed(iface, err) == HOSTAPD_CHAN_VALID) {
50f4f2a0
MK		 876 acs_cleanup(iface);
877 return;
50f4f2a0
MK		 878 }
879
3645fd5a
HS		 880 /* This can possibly happen if channel parameters (secondary
881 * channel, center frequencies) are misconfigured */
882 wpa_printf(MSG_ERROR, "ACS: Possibly channel configuration is invalid, please report this along with your config file.");
50f4f2a0
MK		 883 acs_fail(iface);
884}
885
886
887static void acs_scan_complete(struct hostapd_iface *iface)
888{
889 int err;
890
891 iface->scan_cb = NULL;
892
893 wpa_printf(MSG_DEBUG, "ACS: Using survey based algorithm (acs_num_scans=%d)",
894 iface->conf->acs_num_scans);
895
896 err = hostapd_drv_get_survey(iface->bss[0], 0);
897 if (err) {
898 wpa_printf(MSG_ERROR, "ACS: Failed to get survey data");
4d1e38be 899 goto fail;
50f4f2a0
MK		 900 }
901
902 if (++iface->acs_num_completed_scans < iface->conf->acs_num_scans) {
903 err = acs_request_scan(iface);
904 if (err) {
905 wpa_printf(MSG_ERROR, "ACS: Failed to request scan");
770ecdf2 906 goto fail;
50f4f2a0
MK		 907 }
908
909 return;
910 }
911
912 acs_study(iface);
770ecdf2
HS		 913 return;
914fail:
915 hostapd_acs_completed(iface, 1);
916 acs_fail(iface);
50f4f2a0
MK		 917}
918
919
920static int acs_request_scan(struct hostapd_iface *iface)
921{
922 struct wpa_driver_scan_params params;
923 struct hostapd_channel_data *chan;
924 int i, *freq;
925
926 os_memset(&params, 0, sizeof(params));
927 params.freqs = os_calloc(iface->current_mode->num_channels + 1,
928 sizeof(params.freqs[0]));
929 if (params.freqs == NULL)
930 return -1;
931
932 freq = params.freqs;
933 for (i = 0; i < iface->current_mode->num_channels; i++) {
934 chan = &iface->current_mode->channels[i];
935 if (chan->flag & HOSTAPD_CHAN_DISABLED)
936 continue;
937
567098ec
SD		 938 if (!is_in_chanlist(iface, chan))
939 continue;
940
50f4f2a0
MK		 941 *freq++ = chan->freq;
942 }
943 *freq = 0;
944
d9286d09
NJ		 945 if (params.freqs == freq) {
946 wpa_printf(MSG_ERROR, "ACS: No available channels found");
947 os_free(params.freqs);
948 return -1;
949 }
950
50f4f2a0
MK		 951 iface->scan_cb = acs_scan_complete;
952
953 wpa_printf(MSG_DEBUG, "ACS: Scanning %d / %d",
954 iface->acs_num_completed_scans + 1,
955 iface->conf->acs_num_scans);
956
957 if (hostapd_driver_scan(iface->bss[0], &params) < 0) {
958 wpa_printf(MSG_ERROR, "ACS: Failed to request initial scan");
959 acs_cleanup(iface);
4d1e38be 960 os_free(params.freqs);
50f4f2a0
MK		 961 return -1;
962 }
963
964 os_free(params.freqs);
965 return 0;
966}
967
968
969enum hostapd_chan_status acs_init(struct hostapd_iface *iface)
970{
50f4f2a0
MK		 971 wpa_printf(MSG_INFO, "ACS: Automatic channel selection started, this may take a bit");
972
16689c7c
PX		 973 if (iface->drv_flags & WPA_DRIVER_FLAGS_ACS_OFFLOAD) {
974 wpa_printf(MSG_INFO, "ACS: Offloading to driver");
29be2c09 975 if (hostapd_drv_do_acs(iface->bss[0]))
16689c7c
PX		 976 return HOSTAPD_CHAN_INVALID;
977 return HOSTAPD_CHAN_ACS;
978 }
979
a95cc47a
JM		 980 if (!iface->current_mode)
981 return HOSTAPD_CHAN_INVALID;
982
50f4f2a0
MK		 983 acs_cleanup(iface);
984
29be2c09 985 if (acs_request_scan(iface) < 0)
50f4f2a0
MK		 986 return HOSTAPD_CHAN_INVALID;
987
e1c5faf0 988 hostapd_set_state(iface, HAPD_IFACE_ACS);
ae134e1d
JM		 989 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_STARTED);
990
50f4f2a0
MK		 991 return HOSTAPD_CHAN_ACS;
992}
Unnamed repository; edit this file 'description' to name the repository.