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 "utils/eloop.h"
16 #include "common/ieee802_11_defs.h"
17 #include "common/hw_features_common.h"
18 #include "common/wpa_ctrl.h"
19 #include "drivers/driver.h"
20 #include "hostapd.h"
21 #include "ap_drv_ops.h"
22 #include "ap_config.h"
23 #include "hw_features.h"
24 #include "acs.h"
25
26 /*
27 * Automatic Channel Selection
28 * ===========================
29 *
30 * More info at
31 * ------------
32 * http://wireless.kernel.org/en/users/Documentation/acs
33 *
34 * How to use
35 * ----------
36 * - make sure you have CONFIG_ACS=y in hostapd's .config
37 * - use channel=0 or channel=acs to enable ACS
38 *
39 * How does it work
40 * ----------------
41 * 1. passive scans are used to collect survey data
42 * (it is assumed that scan trigger collection of survey data in driver)
43 * 2. interference factor is calculated for each channel
44 * 3. ideal channel is picked depending on channel width by using adjacent
45 * channel interference factors
46 *
47 * Known limitations
48 * -----------------
49 * - Current implementation depends heavily on the amount of time willing to
50 * spend gathering survey data during hostapd startup. Short traffic bursts
51 * may be missed and a suboptimal channel may be picked.
52 * - Ideal channel may end up overlapping a channel with 40 MHz intolerant BSS
53 *
54 * Todo / Ideas
55 * ------------
56 * - implement other interference computation methods
57 * - BSS/RSSI based
58 * - spectral scan based
59 * (should be possibly to hook this up with current ACS scans)
60 * - add wpa_supplicant support (for P2P)
61 * - collect a histogram of interference over time allowing more educated
62 * guess about an ideal channel (perhaps CSA could be used to migrate AP to a
63 * new "better" channel while running)
64 * - include neighboring BSS scan to avoid conflicts with 40 MHz intolerant BSSs
65 * when choosing the ideal channel
66 *
67 * Survey interference factor implementation details
68 * -------------------------------------------------
69 * Generic interference_factor in struct hostapd_channel_data is used.
70 *
71 * The survey interference factor is defined as the ratio of the
72 * observed busy time over the time we spent on the channel,
73 * this value is then amplified by the observed noise floor on
74 * the channel in comparison to the lowest noise floor observed
75 * on the entire band.
76 *
77 * This corresponds to:
78 * ---
79 * (busy time - tx time) / (active time - tx time) * 2^(chan_nf - band_min_nf)
80 * ---
81 *
82 * The coefficient of 2 reflects the way power in "far-field"
83 * radiation decreases as the square of distance from the antenna [1].
84 * What this does is it decreases the observed busy time ratio if the
85 * noise observed was low but increases it if the noise was high,
86 * proportionally to the way "far field" radiation changes over
87 * distance.
88 *
89 * If channel busy time is not available the fallback is to use channel RX time.
90 *
91 * Since noise floor is in dBm it is necessary to convert it into Watts so that
92 * combined channel interference (e.g., HT40, which uses two channels) can be
93 * calculated easily.
94 * ---
95 * (busy time - tx time) / (active time - tx time) *
96 * 2^(10^(chan_nf/10) - 10^(band_min_nf/10))
97 * ---
98 *
99 * However to account for cases where busy/rx time is 0 (channel load is then
100 * 0%) channel noise floor signal power is combined into the equation so a
101 * channel with lower noise floor is preferred. The equation becomes:
102 * ---
103 * 10^(chan_nf/5) + (busy time - tx time) / (active time - tx time) *
104 * 2^(10^(chan_nf/10) - 10^(band_min_nf/10))
105 * ---
106 *
107 * All this "interference factor" is purely subjective and only time
108 * will tell how usable this is. By using the minimum noise floor we
109 * remove any possible issues due to card calibration. The computation
110 * of the interference factor then is dependent on what the card itself
111 * picks up as the minimum noise, not an actual real possible card
112 * noise value.
113 *
114 * Total interference computation details
115 * --------------------------------------
116 * The above channel interference factor is calculated with no respect to
117 * target operational bandwidth.
118 *
119 * To find an ideal channel the above data is combined by taking into account
120 * the target operational bandwidth and selected band. E.g., on 2.4 GHz channels
121 * overlap with 20 MHz bandwidth, but there is no overlap for 20 MHz bandwidth
122 * on 5 GHz.
123 *
124 * Each valid and possible channel spec (i.e., channel + width) is taken and its
125 * interference factor is computed by summing up interferences of each channel
126 * it overlaps. The one with least total interference is picked up.
127 *
128 * Note: This implies base channel interference factor must be non-negative
129 * allowing easy summing up.
130 *
131 * Example ACS analysis printout
132 * -----------------------------
133 *
134 * ACS: Trying survey-based ACS
135 * ACS: Survey analysis for channel 1 (2412 MHz)
136 * ACS: 1: min_nf=-113 interference_factor=0.0802469 nf=-113 time=162 busy=0 rx=13
137 * ACS: 2: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
138 * ACS: 3: min_nf=-113 interference_factor=0.0679012 nf=-113 time=162 busy=0 rx=11
139 * ACS: 4: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
140 * ACS: 5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
141 * ACS: * interference factor average: 0.0557166
142 * ACS: Survey analysis for channel 2 (2417 MHz)
143 * ACS: 1: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
144 * ACS: 2: min_nf=-113 interference_factor=0.0246914 nf=-113 time=162 busy=0 rx=4
145 * ACS: 3: min_nf=-113 interference_factor=0.037037 nf=-113 time=162 busy=0 rx=6
146 * ACS: 4: min_nf=-113 interference_factor=0.149068 nf=-113 time=161 busy=0 rx=24
147 * ACS: 5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
148 * ACS: * interference factor average: 0.050832
149 * ACS: Survey analysis for channel 3 (2422 MHz)
150 * ACS: 1: min_nf=-113 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
151 * ACS: 2: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
152 * ACS: 3: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
153 * ACS: 4: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
154 * ACS: 5: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
155 * ACS: * interference factor average: 0.0148838
156 * ACS: Survey analysis for channel 4 (2427 MHz)
157 * ACS: 1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
158 * ACS: 2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
159 * ACS: 3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
160 * ACS: 4: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
161 * ACS: 5: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
162 * ACS: * interference factor average: 0.0160801
163 * ACS: Survey analysis for channel 5 (2432 MHz)
164 * ACS: 1: min_nf=-114 interference_factor=0.409938 nf=-113 time=161 busy=0 rx=66
165 * ACS: 2: min_nf=-114 interference_factor=0.0432099 nf=-113 time=162 busy=0 rx=7
166 * ACS: 3: min_nf=-114 interference_factor=0.0124224 nf=-113 time=161 busy=0 rx=2
167 * ACS: 4: min_nf=-114 interference_factor=0.677019 nf=-113 time=161 busy=0 rx=109
168 * ACS: 5: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
169 * ACS: * interference factor average: 0.232244
170 * ACS: Survey analysis for channel 6 (2437 MHz)
171 * ACS: 1: min_nf=-113 interference_factor=0.552795 nf=-113 time=161 busy=0 rx=89
172 * ACS: 2: min_nf=-113 interference_factor=0.0807453 nf=-112 time=161 busy=0 rx=13
173 * ACS: 3: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
174 * ACS: 4: min_nf=-113 interference_factor=0.434783 nf=-112 time=161 busy=0 rx=70
175 * ACS: 5: min_nf=-113 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
176 * ACS: * interference factor average: 0.232298
177 * ACS: Survey analysis for channel 7 (2442 MHz)
178 * ACS: 1: min_nf=-113 interference_factor=0.440994 nf=-112 time=161 busy=0 rx=71
179 * ACS: 2: min_nf=-113 interference_factor=0.385093 nf=-113 time=161 busy=0 rx=62
180 * ACS: 3: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
181 * ACS: 4: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
182 * ACS: 5: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
183 * ACS: * interference factor average: 0.195031
184 * ACS: Survey analysis for channel 8 (2447 MHz)
185 * ACS: 1: min_nf=-114 interference_factor=0.0496894 nf=-112 time=161 busy=0 rx=8
186 * ACS: 2: min_nf=-114 interference_factor=0.0496894 nf=-114 time=161 busy=0 rx=8
187 * ACS: 3: min_nf=-114 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
188 * ACS: 4: min_nf=-114 interference_factor=0.12963 nf=-113 time=162 busy=0 rx=21
189 * ACS: 5: min_nf=-114 interference_factor=0.166667 nf=-114 time=162 busy=0 rx=27
190 * ACS: * interference factor average: 0.0865885
191 * ACS: Survey analysis for channel 9 (2452 MHz)
192 * ACS: 1: min_nf=-114 interference_factor=0.0124224 nf=-114 time=161 busy=0 rx=2
193 * ACS: 2: min_nf=-114 interference_factor=0.0310559 nf=-114 time=161 busy=0 rx=5
194 * ACS: 3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
195 * ACS: 4: min_nf=-114 interference_factor=0.00617284 nf=-114 time=162 busy=0 rx=1
196 * ACS: 5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
197 * ACS: * interference factor average: 0.00993022
198 * ACS: Survey analysis for channel 10 (2457 MHz)
199 * ACS: 1: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
200 * ACS: 2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
201 * ACS: 3: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
202 * ACS: 4: min_nf=-114 interference_factor=0.0493827 nf=-114 time=162 busy=0 rx=8
203 * ACS: 5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
204 * ACS: * interference factor average: 0.0136033
205 * ACS: Survey analysis for channel 11 (2462 MHz)
206 * ACS: 1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
207 * ACS: 2: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
208 * ACS: 3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
209 * ACS: 4: min_nf=-114 interference_factor=0.0432099 nf=-114 time=162 busy=0 rx=7
210 * ACS: 5: min_nf=-114 interference_factor=0.0925926 nf=-114 time=162 busy=0 rx=15
211 * ACS: * interference factor average: 0.0271605
212 * ACS: Survey analysis for channel 12 (2467 MHz)
213 * ACS: 1: min_nf=-114 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
214 * ACS: 2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
215 * ACS: 3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
216 * ACS: 4: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
217 * ACS: 5: min_nf=-114 interference_factor=0.00617284 nf=-113 time=162 busy=0 rx=1
218 * ACS: * interference factor average: 0.0148992
219 * ACS: Survey analysis for channel 13 (2472 MHz)
220 * ACS: 1: min_nf=-114 interference_factor=0.0745342 nf=-114 time=161 busy=0 rx=12
221 * ACS: 2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
222 * ACS: 3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
223 * ACS: 4: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
224 * ACS: 5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
225 * ACS: * interference factor average: 0.0260179
226 * ACS: Survey analysis for selected bandwidth 20MHz
227 * ACS: * channel 1: total interference = 0.121432
228 * ACS: * channel 2: total interference = 0.137512
229 * ACS: * channel 3: total interference = 0.369757
230 * ACS: * channel 4: total interference = 0.546338
231 * ACS: * channel 5: total interference = 0.690538
232 * ACS: * channel 6: total interference = 0.762242
233 * ACS: * channel 7: total interference = 0.756092
234 * ACS: * channel 8: total interference = 0.537451
235 * ACS: * channel 9: total interference = 0.332313
236 * ACS: * channel 10: total interference = 0.152182
237 * ACS: * channel 11: total interference = 0.0916111
238 * ACS: * channel 12: total interference = 0.0816809
239 * ACS: * channel 13: total interference = 0.0680776
240 * ACS: Ideal channel is 13 (2472 MHz) with total interference factor of 0.0680776
241 *
242 * [1] http://en.wikipedia.org/wiki/Near_and_far_field
243 */
244
245 enum bw_type {
246 ACS_BW40,
247 ACS_BW80,
248 ACS_BW160,
249 ACS_BW320_1,
250 ACS_BW320_2,
251 };
252
253 struct bw_item {
254 int first;
255 int last;
256 int center_chan;
257 };
258
259 static const struct bw_item bw_40[] = {
260 { 5180, 5200, 38 }, { 5220, 5240, 46 }, { 5260, 5280, 54 },
261 { 5300, 5320, 62 }, { 5500, 5520, 102 }, { 5540, 5560, 110 },
262 { 5580, 5600, 118 }, { 5620, 5640, 126 }, { 5660, 5680, 134 },
263 { 5700, 5720, 142 }, { 5745, 5765, 151 }, { 5785, 5805, 159 },
264 { 5825, 5845, 167 }, { 5865, 5885, 175 },
265 { 5955, 5975, 3 }, { 5995, 6015, 11 }, { 6035, 6055, 19 },
266 { 6075, 6095, 27 }, { 6115, 6135, 35 }, { 6155, 6175, 43 },
267 { 6195, 6215, 51 }, { 6235, 6255, 59 }, { 6275, 6295, 67 },
268 { 6315, 6335, 75 }, { 6355, 6375, 83 }, { 6395, 6415, 91 },
269 { 6435, 6455, 99 }, { 6475, 6495, 107 }, { 6515, 6535, 115 },
270 { 6555, 6575, 123 }, { 6595, 6615, 131 }, { 6635, 6655, 139 },
271 { 6675, 6695, 147 }, { 6715, 6735, 155 }, { 6755, 6775, 163 },
272 { 6795, 6815, 171 }, { 6835, 6855, 179 }, { 6875, 6895, 187 },
273 { 6915, 6935, 195 }, { 6955, 6975, 203 }, { 6995, 7015, 211 },
274 { 7035, 7055, 219 }, { 7075, 7095, 227}, { -1, -1, -1 }
275 };
276 static const struct bw_item bw_80[] = {
277 { 5180, 5240, 42 }, { 5260, 5320, 58 }, { 5500, 5560, 106 },
278 { 5580, 5640, 122 }, { 5660, 5720, 138 }, { 5745, 5805, 155 },
279 { 5825, 5885, 171},
280 { 5955, 6015, 7 }, { 6035, 6095, 23 }, { 6115, 6175, 39 },
281 { 6195, 6255, 55 }, { 6275, 6335, 71 }, { 6355, 6415, 87 },
282 { 6435, 6495, 103 }, { 6515, 6575, 119 }, { 6595, 6655, 135 },
283 { 6675, 6735, 151 }, { 6755, 6815, 167 }, { 6835, 6895, 183 },
284 { 6915, 6975, 199 }, { 6995, 7055, 215 }, { -1, -1, -1 }
285 };
286 static const struct bw_item bw_160[] = {
287 { 5180, 5320, 50 }, { 5500, 5640, 114 }, { 5745, 5885, 163 },
288 { 5955, 6095, 15 }, { 6115, 6255, 47 }, { 6275, 6415, 79 },
289 { 6435, 6575, 111 }, { 6595, 6735, 143 },
290 { 6755, 6895, 175 }, { 6915, 7055, 207 }, { -1, -1, -1 }
291 };
292 static const struct bw_item bw_320_1[] = {
293 { 5955, 6255, 31 }, { 6275, 6575, 95 }, { 6595, 6895, 159 },
294 { -1, -1, -1 }
295 };
296 static const struct bw_item bw_320_2[] = {
297 { 6115, 6415, 63 }, { 6435, 6735, 127 }, { 6755, 7055, 191 },
298 { -1, -1, -1 }
299 };
300 static const struct bw_item *bw_desc[] = {
301 [ACS_BW40] = bw_40,
302 [ACS_BW80] = bw_80,
303 [ACS_BW160] = bw_160,
304 [ACS_BW320_1] = bw_320_1,
305 [ACS_BW320_2] = bw_320_2,
306 };
307
308
309 static int acs_request_scan(struct hostapd_iface *iface);
310 static int acs_survey_is_sufficient(struct freq_survey *survey);
311 static void acs_scan_retry(void *eloop_data, void *user_data);
312
313
acs_clean_chan_surveys(struct hostapd_channel_data * chan)314 static void acs_clean_chan_surveys(struct hostapd_channel_data *chan)
315 {
316 struct freq_survey *survey, *tmp;
317
318 if (dl_list_empty(&chan->survey_list))
319 return;
320
321 dl_list_for_each_safe(survey, tmp, &chan->survey_list,
322 struct freq_survey, list) {
323 dl_list_del(&survey->list);
324 os_free(survey);
325 }
326 }
327
328
acs_cleanup_mode(struct hostapd_hw_modes * mode)329 static void acs_cleanup_mode(struct hostapd_hw_modes *mode)
330 {
331 int i;
332 struct hostapd_channel_data *chan;
333
334 for (i = 0; i < mode->num_channels; i++) {
335 chan = &mode->channels[i];
336
337 if (chan->flag & HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED)
338 acs_clean_chan_surveys(chan);
339
340 dl_list_init(&chan->survey_list);
341 chan->flag |= HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED;
342 chan->min_nf = 0;
343 chan->punct_bitmap = 0;
344 }
345 }
346
347
acs_cleanup(struct hostapd_iface * iface)348 void acs_cleanup(struct hostapd_iface *iface)
349 {
350 int i;
351
352 for (i = 0; i < iface->num_hw_features; i++)
353 acs_cleanup_mode(&iface->hw_features[i]);
354
355 iface->chans_surveyed = 0;
356 iface->acs_num_completed_scans = 0;
357 iface->acs_num_retries = 0;
358 eloop_cancel_timeout(acs_scan_retry, iface, NULL);
359 }
360
361
acs_fail(struct hostapd_iface * iface)362 static void acs_fail(struct hostapd_iface *iface)
363 {
364 wpa_printf(MSG_ERROR, "ACS: Failed to start");
365 acs_cleanup(iface);
366 hostapd_disable_iface(iface);
367 }
368
369
370 static long double
acs_survey_interference_factor(struct freq_survey * survey,s8 min_nf)371 acs_survey_interference_factor(struct freq_survey *survey, s8 min_nf)
372 {
373 long double factor, busy, total;
374
375 if (survey->filled & SURVEY_HAS_CHAN_TIME_BUSY)
376 busy = survey->channel_time_busy;
377 else if (survey->filled & SURVEY_HAS_CHAN_TIME_RX)
378 busy = survey->channel_time_rx;
379 else {
380 wpa_printf(MSG_ERROR, "ACS: Survey data missing");
381 return 0;
382 }
383
384 total = survey->channel_time;
385
386 if (survey->filled & SURVEY_HAS_CHAN_TIME_TX) {
387 busy -= survey->channel_time_tx;
388 total -= survey->channel_time_tx;
389 }
390
391 /* TODO: figure out the best multiplier for noise floor base */
392 factor = pow(10, survey->nf / 5.0L) +
393 (total ? (busy / total) : 0) *
394 pow(2, pow(10, (long double) survey->nf / 10.0L) -
395 pow(10, (long double) min_nf / 10.0L));
396
397 return factor;
398 }
399
400
401 static void
acs_survey_chan_interference_factor(struct hostapd_iface * iface,struct hostapd_channel_data * chan)402 acs_survey_chan_interference_factor(struct hostapd_iface *iface,
403 struct hostapd_channel_data *chan)
404 {
405 struct freq_survey *survey;
406 unsigned int i = 0;
407 long double int_factor = 0;
408 unsigned count = 0;
409
410 if (dl_list_empty(&chan->survey_list) ||
411 (chan->flag & HOSTAPD_CHAN_DISABLED))
412 return;
413
414 chan->interference_factor = 0;
415
416 dl_list_for_each(survey, &chan->survey_list, struct freq_survey, list)
417 {
418 i++;
419
420 if (!acs_survey_is_sufficient(survey)) {
421 wpa_printf(MSG_DEBUG, "ACS: %d: insufficient data", i);
422 continue;
423 }
424
425 count++;
426 int_factor = acs_survey_interference_factor(survey,
427 iface->lowest_nf);
428 chan->interference_factor += int_factor;
429 wpa_printf(MSG_DEBUG, "ACS: %d: min_nf=%d interference_factor=%Lg nf=%d time=%lu busy=%lu rx=%lu",
430 i, chan->min_nf, int_factor,
431 survey->nf, (unsigned long) survey->channel_time,
432 (unsigned long) survey->channel_time_busy,
433 (unsigned long) survey->channel_time_rx);
434 }
435
436 if (count)
437 chan->interference_factor /= count;
438 }
439
440
acs_usable_bw_chan(const struct hostapd_channel_data * chan,enum bw_type bw)441 static bool acs_usable_bw_chan(const struct hostapd_channel_data *chan,
442 enum bw_type bw)
443 {
444 unsigned int i = 0;
445
446 while (bw_desc[bw][i].first != -1) {
447 if (chan->freq == bw_desc[bw][i].first)
448 return true;
449 i++;
450 }
451
452 return false;
453 }
454
455
acs_get_bw_center_chan(int freq,enum bw_type bw)456 static int acs_get_bw_center_chan(int freq, enum bw_type bw)
457 {
458 unsigned int i = 0;
459
460 while (bw_desc[bw][i].first != -1) {
461 if (freq >= bw_desc[bw][i].first &&
462 freq <= bw_desc[bw][i].last)
463 return bw_desc[bw][i].center_chan;
464 i++;
465 }
466
467 return 0;
468 }
469
470
acs_survey_is_sufficient(struct freq_survey * survey)471 static int acs_survey_is_sufficient(struct freq_survey *survey)
472 {
473 if (!(survey->filled & SURVEY_HAS_NF)) {
474 wpa_printf(MSG_INFO,
475 "ACS: Survey for freq %d is missing noise floor",
476 survey->freq);
477 return 0;
478 }
479
480 if (!(survey->filled & SURVEY_HAS_CHAN_TIME)) {
481 wpa_printf(MSG_INFO,
482 "ACS: Survey for freq %d is missing channel time",
483 survey->freq);
484 return 0;
485 }
486
487 if (!(survey->filled & SURVEY_HAS_CHAN_TIME_BUSY) &&
488 !(survey->filled & SURVEY_HAS_CHAN_TIME_RX)) {
489 wpa_printf(MSG_INFO,
490 "ACS: Survey for freq %d is missing RX and busy time (at least one is required)",
491 survey->freq);
492 return 0;
493 }
494
495 return 1;
496 }
497
498
acs_survey_list_is_sufficient(struct hostapd_channel_data * chan)499 static int acs_survey_list_is_sufficient(struct hostapd_channel_data *chan)
500 {
501 struct freq_survey *survey;
502 int ret = -1;
503
504 dl_list_for_each(survey, &chan->survey_list, struct freq_survey, list)
505 {
506 if (acs_survey_is_sufficient(survey)) {
507 ret = 1;
508 break;
509 }
510 ret = 0;
511 }
512
513 if (ret == -1)
514 ret = 0; /* no survey list entries */
515
516 if (!ret) {
517 wpa_printf(MSG_INFO,
518 "ACS: Channel %d has insufficient survey data",
519 chan->chan);
520 }
521
522 return ret;
523 }
524
525
acs_surveys_are_sufficient_mode(struct hostapd_hw_modes * mode)526 static int acs_surveys_are_sufficient_mode(struct hostapd_hw_modes *mode)
527 {
528 int i;
529 struct hostapd_channel_data *chan;
530
531 for (i = 0; i < mode->num_channels; i++) {
532 chan = &mode->channels[i];
533 if (!(chan->flag & HOSTAPD_CHAN_DISABLED) &&
534 acs_survey_list_is_sufficient(chan))
535 return 1;
536 }
537
538 return 0;
539 }
540
541
acs_surveys_are_sufficient(struct hostapd_iface * iface)542 static int acs_surveys_are_sufficient(struct hostapd_iface *iface)
543 {
544 int i;
545 struct hostapd_hw_modes *mode;
546
547 for (i = 0; i < iface->num_hw_features; i++) {
548 mode = &iface->hw_features[i];
549 if (!hostapd_hw_skip_mode(iface, mode) &&
550 acs_surveys_are_sufficient_mode(mode))
551 return 1;
552 }
553
554 return 0;
555 }
556
557
acs_usable_chan(struct hostapd_channel_data * chan)558 static int acs_usable_chan(struct hostapd_channel_data *chan)
559 {
560 return !dl_list_empty(&chan->survey_list) &&
561 !(chan->flag & HOSTAPD_CHAN_DISABLED) &&
562 acs_survey_list_is_sufficient(chan);
563 }
564
565
is_in_chanlist(struct hostapd_iface * iface,struct hostapd_channel_data * chan)566 static int is_in_chanlist(struct hostapd_iface *iface,
567 struct hostapd_channel_data *chan)
568 {
569 if (!iface->conf->acs_ch_list.num)
570 return 1;
571
572 return freq_range_list_includes(&iface->conf->acs_ch_list, chan->chan);
573 }
574
575
is_in_freqlist(struct hostapd_iface * iface,struct hostapd_channel_data * chan)576 static int is_in_freqlist(struct hostapd_iface *iface,
577 struct hostapd_channel_data *chan)
578 {
579 if (!iface->conf->acs_freq_list.num)
580 return 1;
581
582 return freq_range_list_includes(&iface->conf->acs_freq_list,
583 chan->freq);
584 }
585
586
acs_survey_mode_interference_factor(struct hostapd_iface * iface,struct hostapd_hw_modes * mode)587 static void acs_survey_mode_interference_factor(
588 struct hostapd_iface *iface, struct hostapd_hw_modes *mode)
589 {
590 int i;
591 struct hostapd_channel_data *chan;
592
593 for (i = 0; i < mode->num_channels; i++) {
594 chan = &mode->channels[i];
595
596 if (!acs_usable_chan(chan))
597 continue;
598
599 if ((chan->flag & HOSTAPD_CHAN_RADAR) &&
600 iface->conf->acs_exclude_dfs)
601 continue;
602
603 if (!is_in_chanlist(iface, chan))
604 continue;
605
606 if (!is_in_freqlist(iface, chan))
607 continue;
608
609 if (chan->max_tx_power < iface->conf->min_tx_power)
610 continue;
611
612 if ((chan->flag & HOSTAPD_CHAN_INDOOR_ONLY) &&
613 iface->conf->country[2] == 0x4f)
614 continue;
615
616 wpa_printf(MSG_DEBUG, "ACS: Survey analysis for channel %d (%d MHz)",
617 chan->chan, chan->freq);
618
619 acs_survey_chan_interference_factor(iface, chan);
620
621 wpa_printf(MSG_DEBUG, "ACS: * interference factor average: %Lg",
622 chan->interference_factor);
623 }
624 }
625
626
acs_survey_all_chans_interference_factor(struct hostapd_iface * iface)627 static void acs_survey_all_chans_interference_factor(
628 struct hostapd_iface *iface)
629 {
630 int i;
631 struct hostapd_hw_modes *mode;
632
633 for (i = 0; i < iface->num_hw_features; i++) {
634 mode = &iface->hw_features[i];
635 if (!hostapd_hw_skip_mode(iface, mode))
636 acs_survey_mode_interference_factor(iface, mode);
637 }
638 }
639
640
641 static struct hostapd_channel_data *
acs_find_chan_mode(struct hostapd_hw_modes * mode,int freq)642 acs_find_chan_mode(struct hostapd_hw_modes *mode, int freq)
643 {
644 struct hostapd_channel_data *chan;
645 int i;
646
647 for (i = 0; i < mode->num_channels; i++) {
648 chan = &mode->channels[i];
649
650 if (chan->flag & HOSTAPD_CHAN_DISABLED)
651 continue;
652
653 if (chan->freq == freq)
654 return chan;
655 }
656
657 return NULL;
658 }
659
660
661 static enum hostapd_hw_mode
acs_find_mode(struct hostapd_iface * iface,int freq)662 acs_find_mode(struct hostapd_iface *iface, int freq)
663 {
664 int i;
665 struct hostapd_hw_modes *mode;
666 struct hostapd_channel_data *chan;
667
668 for (i = 0; i < iface->num_hw_features; i++) {
669 mode = &iface->hw_features[i];
670 if (!hostapd_hw_skip_mode(iface, mode)) {
671 chan = acs_find_chan_mode(mode, freq);
672 if (chan)
673 return mode->mode;
674 }
675 }
676
677 return HOSTAPD_MODE_IEEE80211ANY;
678 }
679
680
681 static struct hostapd_channel_data *
acs_find_chan(struct hostapd_iface * iface,int freq)682 acs_find_chan(struct hostapd_iface *iface, int freq)
683 {
684 int i;
685 struct hostapd_hw_modes *mode;
686 struct hostapd_channel_data *chan;
687
688 for (i = 0; i < iface->num_hw_features; i++) {
689 mode = &iface->hw_features[i];
690 if (!hostapd_hw_skip_mode(iface, mode)) {
691 chan = acs_find_chan_mode(mode, freq);
692 if (chan)
693 return chan;
694 }
695 }
696
697 return NULL;
698 }
699
700
is_24ghz_mode(enum hostapd_hw_mode mode)701 static int is_24ghz_mode(enum hostapd_hw_mode mode)
702 {
703 return mode == HOSTAPD_MODE_IEEE80211B ||
704 mode == HOSTAPD_MODE_IEEE80211G;
705 }
706
707
is_common_24ghz_chan(int chan)708 static int is_common_24ghz_chan(int chan)
709 {
710 return chan == 1 || chan == 6 || chan == 11;
711 }
712
713
714 #ifndef ACS_ADJ_WEIGHT
715 #define ACS_ADJ_WEIGHT 0.85
716 #endif /* ACS_ADJ_WEIGHT */
717
718 #ifndef ACS_NEXT_ADJ_WEIGHT
719 #define ACS_NEXT_ADJ_WEIGHT 0.55
720 #endif /* ACS_NEXT_ADJ_WEIGHT */
721
722 #ifndef ACS_24GHZ_PREFER_1_6_11
723 /*
724 * Select commonly used channels 1, 6, 11 by default even if a neighboring
725 * channel has a smaller interference factor as long as it is not better by more
726 * than this multiplier.
727 */
728 #define ACS_24GHZ_PREFER_1_6_11 0.8
729 #endif /* ACS_24GHZ_PREFER_1_6_11 */
730
731
732 #ifdef CONFIG_IEEE80211BE
acs_update_puncturing_bitmap(struct hostapd_iface * iface,struct hostapd_hw_modes * mode,u32 bw,int n_chans,struct hostapd_channel_data * chan,long double factor,int index_primary)733 static void acs_update_puncturing_bitmap(struct hostapd_iface *iface,
734 struct hostapd_hw_modes *mode, u32 bw,
735 int n_chans,
736 struct hostapd_channel_data *chan,
737 long double factor,
738 int index_primary)
739 {
740 struct hostapd_config *conf = iface->conf;
741 struct hostapd_channel_data *adj_chan = NULL, *first_chan = chan;
742 int i;
743 long double threshold;
744
745 /*
746 * If threshold is 0 or user configured puncturing pattern is
747 * available then don't add additional puncturing.
748 */
749 if (!conf->punct_acs_threshold || conf->punct_bitmap)
750 return;
751
752 if (is_24ghz_mode(mode->mode) || bw < 80)
753 return;
754
755 threshold = factor * conf->punct_acs_threshold / 100;
756 for (i = 0; i < n_chans; i++) {
757 int adj_freq;
758
759 if (i == index_primary)
760 continue; /* Cannot puncture primary channel */
761
762 if (i > index_primary)
763 adj_freq = chan->freq + (i - index_primary) * 20;
764 else
765 adj_freq = chan->freq - (index_primary - i) * 20;
766
767 adj_chan = acs_find_chan(iface, adj_freq);
768 if (!adj_chan) {
769 chan->punct_bitmap = 0;
770 return;
771 }
772
773 if (i == 0)
774 first_chan = adj_chan;
775
776 if (adj_chan->interference_factor > threshold)
777 chan->punct_bitmap |= BIT(i);
778 }
779
780 if (!is_punct_bitmap_valid(bw, (chan->freq - first_chan->freq) / 20,
781 chan->punct_bitmap))
782 chan->punct_bitmap = 0;
783 }
784 #endif /* CONFIG_IEEE80211BE */
785
786
787 static bool
acs_usable_bw320_chan(struct hostapd_iface * iface,struct hostapd_channel_data * chan,int * bw320_offset)788 acs_usable_bw320_chan(struct hostapd_iface *iface,
789 struct hostapd_channel_data *chan, int *bw320_offset)
790 {
791 const char *bw320_str[] = { "320 MHz", "320 MHz-1", "320 MHz-2" };
792 int conf_bw320_offset = hostapd_get_bw320_offset(iface->conf);
793
794 *bw320_offset = 0;
795 switch (conf_bw320_offset) {
796 case 1:
797 if (acs_usable_bw_chan(chan, ACS_BW320_1))
798 *bw320_offset = 1;
799 break;
800 case 2:
801 if (acs_usable_bw_chan(chan, ACS_BW320_2))
802 *bw320_offset = 2;
803 break;
804 case 0:
805 default:
806 conf_bw320_offset = 0;
807 if (acs_usable_bw_chan(chan, ACS_BW320_1))
808 *bw320_offset = 1;
809 else if (acs_usable_bw_chan(chan, ACS_BW320_2))
810 *bw320_offset = 2;
811 break;
812 }
813
814 if (!*bw320_offset)
815 wpa_printf(MSG_DEBUG,
816 "ACS: Channel %d: not allowed as primary channel for %s bandwidth",
817 chan->chan, bw320_str[conf_bw320_offset]);
818
819 return *bw320_offset != 0;
820 }
821
822
823 static void
acs_find_ideal_chan_mode(struct hostapd_iface * iface,struct hostapd_hw_modes * mode,int n_chans,u32 bw,struct hostapd_channel_data ** rand_chan,struct hostapd_channel_data ** ideal_chan,long double * ideal_factor)824 acs_find_ideal_chan_mode(struct hostapd_iface *iface,
825 struct hostapd_hw_modes *mode,
826 int n_chans, u32 bw,
827 struct hostapd_channel_data **rand_chan,
828 struct hostapd_channel_data **ideal_chan,
829 long double *ideal_factor)
830 {
831 struct hostapd_channel_data *chan, *adj_chan = NULL, *best;
832 long double factor;
833 int i, j;
834 int bw320_offset = 0, ideal_bw320_offset = 0;
835 unsigned int k;
836 int secondary_channel = 1, freq_offset;
837 #ifdef CONFIG_IEEE80211BE
838 int index_primary = 0;
839 #endif /* CONFIG_IEEE80211BE */
840
841 if (is_24ghz_mode(mode->mode))
842 secondary_channel = iface->conf->secondary_channel;
843
844 for (i = 0; i < mode->num_channels; i++) {
845 double total_weight = 0;
846 struct acs_bias *bias, tmp_bias;
847
848 chan = &mode->channels[i];
849
850 /* Since in the current ACS implementation the first channel is
851 * always a primary channel, skip channels not available as
852 * primary until more sophisticated channel selection is
853 * implemented.
854 *
855 * If this implementation is changed to allow any channel in
856 * the bandwidth to be the primary one, the last parameter to
857 * acs_update_puncturing_bitmap() should be changed to the index
858 * of the primary channel
859 */
860 if (!chan_pri_allowed(chan))
861 continue;
862
863 if ((chan->flag & HOSTAPD_CHAN_RADAR) &&
864 iface->conf->acs_exclude_dfs)
865 continue;
866
867 if (!is_in_chanlist(iface, chan))
868 continue;
869
870 if (!is_in_freqlist(iface, chan))
871 continue;
872
873 if (chan->max_tx_power < iface->conf->min_tx_power)
874 continue;
875
876 if ((chan->flag & HOSTAPD_CHAN_INDOOR_ONLY) &&
877 iface->conf->country[2] == 0x4f)
878 continue;
879
880 if (!chan_bw_allowed(chan, bw, secondary_channel != -1, 1)) {
881 wpa_printf(MSG_DEBUG,
882 "ACS: Channel %d: BW %u is not supported",
883 chan->chan, bw);
884 continue;
885 }
886
887 /* HT40 on 5 GHz has a limited set of primary channels as per
888 * 11n Annex J */
889 if (mode->mode == HOSTAPD_MODE_IEEE80211A &&
890 ((iface->conf->ieee80211n &&
891 iface->conf->secondary_channel) ||
892 is_6ghz_freq(chan->freq)) &&
893 !acs_usable_bw_chan(chan, ACS_BW40)) {
894 wpa_printf(MSG_DEBUG,
895 "ACS: Channel %d: not allowed as primary channel for 40 MHz bandwidth",
896 chan->chan);
897 continue;
898 }
899
900 if (mode->mode == HOSTAPD_MODE_IEEE80211A &&
901 (iface->conf->ieee80211ac || iface->conf->ieee80211ax ||
902 iface->conf->ieee80211be)) {
903 if (hostapd_get_oper_chwidth(iface->conf) ==
904 CONF_OPER_CHWIDTH_80MHZ &&
905 !acs_usable_bw_chan(chan, ACS_BW80)) {
906 wpa_printf(MSG_DEBUG,
907 "ACS: Channel %d: not allowed as primary channel for 80 MHz bandwidth",
908 chan->chan);
909 continue;
910 }
911
912 if (hostapd_get_oper_chwidth(iface->conf) ==
913 CONF_OPER_CHWIDTH_160MHZ &&
914 !acs_usable_bw_chan(chan, ACS_BW160)) {
915 wpa_printf(MSG_DEBUG,
916 "ACS: Channel %d: not allowed as primary channel for 160 MHz bandwidth",
917 chan->chan);
918 continue;
919 }
920 }
921
922 if (mode->mode == HOSTAPD_MODE_IEEE80211A &&
923 iface->conf->ieee80211be) {
924 if (hostapd_get_oper_chwidth(iface->conf) ==
925 CONF_OPER_CHWIDTH_320MHZ &&
926 !acs_usable_bw320_chan(iface, chan, &bw320_offset))
927 continue;
928 }
929
930 factor = 0;
931 best = NULL;
932 if (acs_usable_chan(chan)) {
933 factor = chan->interference_factor;
934 total_weight = 1;
935 best = chan;
936 }
937
938 for (j = 1; j < n_chans; j++) {
939 adj_chan = acs_find_chan(iface, chan->freq +
940 j * secondary_channel * 20);
941 if (!adj_chan)
942 break;
943
944 if (!chan_bw_allowed(adj_chan, bw, 1, 0)) {
945 wpa_printf(MSG_DEBUG,
946 "ACS: PRI Channel %d: secondary channel %d BW %u is not supported",
947 chan->chan, adj_chan->chan, bw);
948 break;
949 }
950
951 if (!acs_usable_chan(adj_chan))
952 continue;
953
954 factor += adj_chan->interference_factor;
955 total_weight += 1;
956
957 /* find the best channel in this segment */
958 if (!best || adj_chan->interference_factor <
959 best->interference_factor)
960 best = adj_chan;
961 }
962
963 if (j != n_chans) {
964 wpa_printf(MSG_DEBUG, "ACS: Channel %d: not enough bandwidth",
965 chan->chan);
966 continue;
967 }
968
969 /* If the AP is in the 5 GHz or 6 GHz band, lets prefer a less
970 * crowded primary channel if one was found in the segment */
971 if (iface->current_mode &&
972 iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A &&
973 best && chan != best) {
974 wpa_printf(MSG_DEBUG,
975 "ACS: promoting channel %d over %d (less interference %Lg/%Lg)",
976 best->chan, chan->chan,
977 chan->interference_factor,
978 best->interference_factor);
979 #ifdef CONFIG_IEEE80211BE
980 index_primary = (chan->freq - best->freq) / 20;
981 #endif /* CONFIG_IEEE80211BE */
982 chan = best;
983 }
984
985 /* 2.4 GHz has overlapping 20 MHz channels. Include adjacent
986 * channel interference factor. */
987 if (is_24ghz_mode(mode->mode)) {
988 for (j = 0; j < n_chans; j++) {
989 freq_offset = j * 20 * secondary_channel;
990 adj_chan = acs_find_chan(iface, chan->freq +
991 freq_offset - 5);
992 if (adj_chan && acs_usable_chan(adj_chan)) {
993 factor += ACS_ADJ_WEIGHT *
994 adj_chan->interference_factor;
995 total_weight += ACS_ADJ_WEIGHT;
996 }
997
998 adj_chan = acs_find_chan(iface, chan->freq +
999 freq_offset - 10);
1000 if (adj_chan && acs_usable_chan(adj_chan)) {
1001 factor += ACS_NEXT_ADJ_WEIGHT *
1002 adj_chan->interference_factor;
1003 total_weight += ACS_NEXT_ADJ_WEIGHT;
1004 }
1005
1006 adj_chan = acs_find_chan(iface, chan->freq +
1007 freq_offset + 5);
1008 if (adj_chan && acs_usable_chan(adj_chan)) {
1009 factor += ACS_ADJ_WEIGHT *
1010 adj_chan->interference_factor;
1011 total_weight += ACS_ADJ_WEIGHT;
1012 }
1013
1014 adj_chan = acs_find_chan(iface, chan->freq +
1015 freq_offset + 10);
1016 if (adj_chan && acs_usable_chan(adj_chan)) {
1017 factor += ACS_NEXT_ADJ_WEIGHT *
1018 adj_chan->interference_factor;
1019 total_weight += ACS_NEXT_ADJ_WEIGHT;
1020 }
1021 }
1022 }
1023
1024 if (total_weight == 0)
1025 continue;
1026
1027 factor /= total_weight;
1028
1029 bias = NULL;
1030 if (iface->conf->acs_chan_bias) {
1031 for (k = 0; k < iface->conf->num_acs_chan_bias; k++) {
1032 bias = &iface->conf->acs_chan_bias[k];
1033 if (bias->channel == chan->chan)
1034 break;
1035 bias = NULL;
1036 }
1037 } else if (is_24ghz_mode(mode->mode) &&
1038 is_common_24ghz_chan(chan->chan)) {
1039 tmp_bias.channel = chan->chan;
1040 tmp_bias.bias = ACS_24GHZ_PREFER_1_6_11;
1041 bias = &tmp_bias;
1042 }
1043
1044 if (bias) {
1045 factor *= bias->bias;
1046 wpa_printf(MSG_DEBUG,
1047 "ACS: * channel %d: total interference = %Lg (%f bias)",
1048 chan->chan, factor, bias->bias);
1049 } else {
1050 wpa_printf(MSG_DEBUG,
1051 "ACS: * channel %d: total interference = %Lg",
1052 chan->chan, factor);
1053 }
1054
1055 if (acs_usable_chan(chan) &&
1056 (!*ideal_chan || factor < *ideal_factor)) {
1057 /* Reset puncturing bitmap for the previous ideal
1058 * channel */
1059 if (*ideal_chan)
1060 (*ideal_chan)->punct_bitmap = 0;
1061
1062 *ideal_factor = factor;
1063 *ideal_chan = chan;
1064 ideal_bw320_offset = bw320_offset;
1065
1066 #ifdef CONFIG_IEEE80211BE
1067 if (iface->conf->ieee80211be)
1068 acs_update_puncturing_bitmap(iface, mode, bw,
1069 n_chans, chan,
1070 factor,
1071 index_primary);
1072 #endif /* CONFIG_IEEE80211BE */
1073 }
1074
1075 /* This channel would at least be usable */
1076 if (!(*rand_chan)) {
1077 *rand_chan = chan;
1078 ideal_bw320_offset = bw320_offset;
1079 }
1080 }
1081
1082 hostapd_set_and_check_bw320_offset(iface->conf, ideal_bw320_offset);
1083 }
1084
1085
1086 /*
1087 * At this point it's assumed chan->interference_factor has been computed.
1088 * This function should be reusable regardless of interference computation
1089 * option (survey, BSS, spectral, ...). chan->interference factor must be
1090 * summable (i.e., must be always greater than zero).
1091 */
1092 static struct hostapd_channel_data *
acs_find_ideal_chan(struct hostapd_iface * iface)1093 acs_find_ideal_chan(struct hostapd_iface *iface)
1094 {
1095 struct hostapd_channel_data *ideal_chan = NULL,
1096 *rand_chan = NULL;
1097 long double ideal_factor = 0;
1098 int i;
1099 int n_chans = 1;
1100 u32 bw;
1101 struct hostapd_hw_modes *mode;
1102
1103 if (is_6ghz_op_class(iface->conf->op_class)) {
1104 bw = op_class_to_bandwidth(iface->conf->op_class);
1105 n_chans = bw / 20;
1106 goto bw_selected;
1107 }
1108
1109 if (iface->conf->ieee80211n &&
1110 iface->conf->secondary_channel)
1111 n_chans = 2;
1112
1113 if (iface->conf->ieee80211ac || iface->conf->ieee80211ax ||
1114 iface->conf->ieee80211be) {
1115 switch (hostapd_get_oper_chwidth(iface->conf)) {
1116 case CONF_OPER_CHWIDTH_80MHZ:
1117 n_chans = 4;
1118 break;
1119 case CONF_OPER_CHWIDTH_160MHZ:
1120 n_chans = 8;
1121 break;
1122 case CONF_OPER_CHWIDTH_320MHZ:
1123 n_chans = 16;
1124 break;
1125 default:
1126 break;
1127 }
1128 }
1129
1130 bw = num_chan_to_bw(n_chans);
1131
1132 bw_selected:
1133 /* TODO: VHT/HE80+80. Update acs_adjust_center_freq() too. */
1134
1135 wpa_printf(MSG_DEBUG,
1136 "ACS: Survey analysis for selected bandwidth %d MHz", bw);
1137
1138 for (i = 0; i < iface->num_hw_features; i++) {
1139 mode = &iface->hw_features[i];
1140 if (!hostapd_hw_skip_mode(iface, mode))
1141 acs_find_ideal_chan_mode(iface, mode, n_chans, bw,
1142 &rand_chan, &ideal_chan,
1143 &ideal_factor);
1144 }
1145
1146 if (ideal_chan) {
1147 wpa_printf(MSG_DEBUG, "ACS: Ideal channel is %d (%d MHz) with total interference factor of %Lg",
1148 ideal_chan->chan, ideal_chan->freq, ideal_factor);
1149
1150 #ifdef CONFIG_IEEE80211BE
1151 if (iface->conf->punct_acs_threshold)
1152 wpa_printf(MSG_DEBUG, "ACS: RU puncturing bitmap 0x%x",
1153 ideal_chan->punct_bitmap);
1154 #endif /* CONFIG_IEEE80211BE */
1155
1156 return ideal_chan;
1157 }
1158
1159 return rand_chan;
1160 }
1161
1162
acs_adjust_secondary(struct hostapd_iface * iface)1163 static void acs_adjust_secondary(struct hostapd_iface *iface)
1164 {
1165 unsigned int i;
1166
1167 /* When working with bandwidth over 20 MHz on the 5 GHz or 6 GHz band,
1168 * ACS can return a secondary channel which is not the first channel of
1169 * the segment and we need to adjust. */
1170 if (!iface->conf->secondary_channel ||
1171 acs_find_mode(iface, iface->freq) != HOSTAPD_MODE_IEEE80211A)
1172 return;
1173
1174 wpa_printf(MSG_DEBUG,
1175 "ACS: Adjusting HT/VHT/HE/EHT secondary frequency");
1176
1177 for (i = 0; bw_desc[ACS_BW40][i].first != -1; i++) {
1178 if (iface->freq == bw_desc[ACS_BW40][i].first)
1179 iface->conf->secondary_channel = 1;
1180 else if (iface->freq == bw_desc[ACS_BW40][i].last)
1181 iface->conf->secondary_channel = -1;
1182 }
1183 }
1184
1185
acs_adjust_center_freq(struct hostapd_iface * iface)1186 static void acs_adjust_center_freq(struct hostapd_iface *iface)
1187 {
1188 int center;
1189
1190 wpa_printf(MSG_DEBUG, "ACS: Adjusting center frequency");
1191
1192 switch (hostapd_get_oper_chwidth(iface->conf)) {
1193 case CONF_OPER_CHWIDTH_USE_HT:
1194 if (iface->conf->secondary_channel &&
1195 iface->freq >= 2400 && iface->freq < 2500)
1196 center = iface->conf->channel +
1197 2 * iface->conf->secondary_channel;
1198 else if (iface->conf->secondary_channel)
1199 center = acs_get_bw_center_chan(iface->freq, ACS_BW40);
1200 else
1201 center = iface->conf->channel;
1202 break;
1203 case CONF_OPER_CHWIDTH_80MHZ:
1204 center = acs_get_bw_center_chan(iface->freq, ACS_BW80);
1205 break;
1206 case CONF_OPER_CHWIDTH_160MHZ:
1207 center = acs_get_bw_center_chan(iface->freq, ACS_BW160);
1208 break;
1209 case CONF_OPER_CHWIDTH_320MHZ:
1210 switch (hostapd_get_bw320_offset(iface->conf)) {
1211 case 1:
1212 center = acs_get_bw_center_chan(iface->freq,
1213 ACS_BW320_1);
1214 break;
1215 case 2:
1216 center = acs_get_bw_center_chan(iface->freq,
1217 ACS_BW320_2);
1218 break;
1219 default:
1220 wpa_printf(MSG_INFO,
1221 "ACS: BW320 offset is not selected");
1222 return;
1223 }
1224
1225 break;
1226 default:
1227 /* TODO: How can this be calculated? Adjust
1228 * acs_find_ideal_chan() */
1229 wpa_printf(MSG_INFO,
1230 "ACS: Only VHT20/40/80/160/320 is supported now");
1231 return;
1232 }
1233
1234 hostapd_set_oper_centr_freq_seg0_idx(iface->conf, center);
1235 }
1236
1237
acs_study_survey_based(struct hostapd_iface * iface)1238 static int acs_study_survey_based(struct hostapd_iface *iface)
1239 {
1240 wpa_printf(MSG_DEBUG, "ACS: Trying survey-based ACS");
1241
1242 if (!iface->chans_surveyed) {
1243 wpa_printf(MSG_ERROR, "ACS: Unable to collect survey data");
1244 return -1;
1245 }
1246
1247 if (!acs_surveys_are_sufficient(iface)) {
1248 wpa_printf(MSG_ERROR, "ACS: Surveys have insufficient data");
1249 return -1;
1250 }
1251
1252 acs_survey_all_chans_interference_factor(iface);
1253 return 0;
1254 }
1255
1256
acs_study_options(struct hostapd_iface * iface)1257 static int acs_study_options(struct hostapd_iface *iface)
1258 {
1259 if (acs_study_survey_based(iface) == 0)
1260 return 0;
1261
1262 /* TODO: If no surveys are available/sufficient this is a good
1263 * place to fallback to BSS-based ACS */
1264
1265 return -1;
1266 }
1267
1268
acs_study(struct hostapd_iface * iface)1269 static void acs_study(struct hostapd_iface *iface)
1270 {
1271 struct hostapd_channel_data *ideal_chan;
1272 int err;
1273
1274 err = acs_study_options(iface);
1275 if (err < 0) {
1276 wpa_printf(MSG_ERROR, "ACS: All study options have failed");
1277 goto fail;
1278 }
1279
1280 ideal_chan = acs_find_ideal_chan(iface);
1281 if (!ideal_chan) {
1282 wpa_printf(MSG_ERROR, "ACS: Failed to compute ideal channel");
1283 err = -1;
1284 goto fail;
1285 }
1286
1287 iface->conf->channel = ideal_chan->chan;
1288 iface->freq = ideal_chan->freq;
1289 #ifdef CONFIG_IEEE80211BE
1290 iface->conf->punct_bitmap = ideal_chan->punct_bitmap;
1291 #endif /* CONFIG_IEEE80211BE */
1292
1293 if (iface->conf->ieee80211ac || iface->conf->ieee80211ax ||
1294 iface->conf->ieee80211be) {
1295 acs_adjust_secondary(iface);
1296 acs_adjust_center_freq(iface);
1297 }
1298
1299 err = hostapd_select_hw_mode(iface);
1300 if (err) {
1301 wpa_printf(MSG_ERROR,
1302 "ACS: Could not (err: %d) select hw_mode for freq=%d channel=%d",
1303 err, iface->freq, iface->conf->channel);
1304 err = -1;
1305 goto fail;
1306 }
1307
1308 err = 0;
1309 fail:
1310 /*
1311 * hostapd_setup_interface_complete() will return -1 on failure,
1312 * 0 on success and 0 is HOSTAPD_CHAN_VALID :)
1313 */
1314 if (hostapd_acs_completed(iface, err) == HOSTAPD_CHAN_VALID) {
1315 acs_cleanup(iface);
1316 return;
1317 }
1318
1319 /* This can possibly happen if channel parameters (secondary
1320 * channel, center frequencies) are misconfigured */
1321 wpa_printf(MSG_ERROR, "ACS: Possibly channel configuration is invalid, please report this along with your config file.");
1322 acs_fail(iface);
1323 }
1324
1325
acs_scan_complete(struct hostapd_iface * iface)1326 static void acs_scan_complete(struct hostapd_iface *iface)
1327 {
1328 int err;
1329
1330 iface->scan_cb = NULL;
1331 iface->acs_num_retries = 0;
1332
1333 wpa_printf(MSG_DEBUG, "ACS: Using survey based algorithm (acs_num_scans=%d)",
1334 iface->conf->acs_num_scans);
1335
1336 err = hostapd_drv_get_survey(iface->bss[0], 0);
1337 if (err) {
1338 wpa_printf(MSG_ERROR, "ACS: Failed to get survey data");
1339 goto fail;
1340 }
1341
1342 if (++iface->acs_num_completed_scans < iface->conf->acs_num_scans) {
1343 err = acs_request_scan(iface);
1344 if (err && err != -EBUSY) {
1345 wpa_printf(MSG_ERROR, "ACS: Failed to request scan");
1346 goto fail;
1347 }
1348
1349 return;
1350 }
1351
1352 acs_study(iface);
1353 return;
1354 fail:
1355 hostapd_acs_completed(iface, 1);
1356 acs_fail(iface);
1357 }
1358
1359
acs_request_scan_add_freqs(struct hostapd_iface * iface,struct hostapd_hw_modes * mode,int * freq)1360 static int * acs_request_scan_add_freqs(struct hostapd_iface *iface,
1361 struct hostapd_hw_modes *mode,
1362 int *freq)
1363 {
1364 struct hostapd_channel_data *chan;
1365 int i;
1366
1367 for (i = 0; i < mode->num_channels; i++) {
1368 chan = &mode->channels[i];
1369 if ((chan->flag & HOSTAPD_CHAN_DISABLED) ||
1370 ((chan->flag & HOSTAPD_CHAN_RADAR) &&
1371 iface->conf->acs_exclude_dfs))
1372 continue;
1373
1374 if (!is_in_chanlist(iface, chan))
1375 continue;
1376
1377 if (!is_in_freqlist(iface, chan))
1378 continue;
1379
1380 if (chan->max_tx_power < iface->conf->min_tx_power)
1381 continue;
1382
1383 if ((chan->flag & HOSTAPD_CHAN_INDOOR_ONLY) &&
1384 iface->conf->country[2] == 0x4f)
1385 continue;
1386
1387 *freq++ = chan->freq;
1388 }
1389
1390 return freq;
1391 }
1392
1393
acs_request_scan(struct hostapd_iface * iface)1394 static int acs_request_scan(struct hostapd_iface *iface)
1395 {
1396 struct wpa_driver_scan_params params;
1397 int i, *freq, ret;
1398 int num_channels;
1399 struct hostapd_hw_modes *mode;
1400
1401 os_memset(¶ms, 0, sizeof(params));
1402
1403 num_channels = 0;
1404 for (i = 0; i < iface->num_hw_features; i++) {
1405 mode = &iface->hw_features[i];
1406 if (!hostapd_hw_skip_mode(iface, mode))
1407 num_channels += mode->num_channels;
1408 }
1409
1410 params.freqs = os_calloc(num_channels + 1, sizeof(params.freqs[0]));
1411 if (params.freqs == NULL)
1412 return -1;
1413
1414 freq = params.freqs;
1415
1416 for (i = 0; i < iface->num_hw_features; i++) {
1417 mode = &iface->hw_features[i];
1418 if (!hostapd_hw_skip_mode(iface, mode))
1419 freq = acs_request_scan_add_freqs(iface, mode, freq);
1420 }
1421
1422 *freq = 0;
1423
1424 if (params.freqs == freq) {
1425 wpa_printf(MSG_ERROR, "ACS: No available channels found");
1426 os_free(params.freqs);
1427 return -1;
1428 }
1429
1430 if (!iface->acs_num_retries)
1431 wpa_printf(MSG_DEBUG, "ACS: Scanning %d / %d",
1432 iface->acs_num_completed_scans + 1,
1433 iface->conf->acs_num_scans);
1434 else
1435 wpa_printf(MSG_DEBUG,
1436 "ACS: Re-try scanning attempt %d (%d / %d)",
1437 iface->acs_num_retries,
1438 iface->acs_num_completed_scans + 1,
1439 iface->conf->acs_num_scans);
1440
1441 ret = hostapd_driver_scan(iface->bss[0], ¶ms);
1442 os_free(params.freqs);
1443
1444 if (ret == -EBUSY) {
1445 iface->acs_num_retries++;
1446 if (iface->acs_num_retries >= ACS_SCAN_RETRY_MAX_COUNT) {
1447 wpa_printf(MSG_ERROR,
1448 "ACS: Failed to request initial scan (all re-attempts failed)");
1449 acs_fail(iface);
1450 return -1;
1451 }
1452
1453 wpa_printf(MSG_INFO,
1454 "Failed to request acs scan ret=%d (%s) - try to scan after %d seconds",
1455 ret, strerror(-ret), ACS_SCAN_RETRY_INTERVAL);
1456 eloop_cancel_timeout(acs_scan_retry, iface, NULL);
1457 eloop_register_timeout(ACS_SCAN_RETRY_INTERVAL, 0,
1458 acs_scan_retry, iface, NULL);
1459 return 0;
1460 }
1461
1462 if (ret < 0) {
1463 wpa_printf(MSG_ERROR, "ACS: Failed to request initial scan");
1464 acs_cleanup(iface);
1465 return -1;
1466 }
1467
1468 iface->scan_cb = acs_scan_complete;
1469
1470 return 0;
1471 }
1472
1473
acs_scan_retry(void * eloop_data,void * user_data)1474 static void acs_scan_retry(void *eloop_data, void *user_data)
1475 {
1476 struct hostapd_iface *iface = eloop_data;
1477
1478 if (acs_request_scan(iface)) {
1479 wpa_printf(MSG_ERROR,
1480 "ACS: Failed to request re-try of initial scan");
1481 acs_fail(iface);
1482 }
1483 }
1484
1485
acs_init(struct hostapd_iface * iface)1486 enum hostapd_chan_status acs_init(struct hostapd_iface *iface)
1487 {
1488 int err;
1489
1490 wpa_printf(MSG_INFO, "ACS: Automatic channel selection started, this may take a bit");
1491
1492 if (iface->drv_flags & WPA_DRIVER_FLAGS_ACS_OFFLOAD) {
1493 wpa_printf(MSG_INFO, "ACS: Offloading to driver");
1494
1495 err = hostapd_drv_do_acs(iface->bss[0]);
1496 if (err) {
1497 if (err == 1)
1498 return HOSTAPD_CHAN_INVALID_NO_IR;
1499 return HOSTAPD_CHAN_INVALID;
1500 }
1501
1502 return HOSTAPD_CHAN_ACS;
1503 }
1504
1505 if (!iface->current_mode &&
1506 iface->conf->hw_mode != HOSTAPD_MODE_IEEE80211ANY)
1507 return HOSTAPD_CHAN_INVALID;
1508
1509 acs_cleanup(iface);
1510
1511 if (acs_request_scan(iface) < 0)
1512 return HOSTAPD_CHAN_INVALID;
1513
1514 hostapd_set_state(iface, HAPD_IFACE_ACS);
1515 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, ACS_EVENT_STARTED);
1516
1517 return HOSTAPD_CHAN_ACS;
1518 }
1519