hostapd: Add Automatic Channel Selection (ACS) support

This adds ACS support to hostapd. Currently only survey-based
algorithm is available.

To use ACS you need to enable CONFIG_ACS=y in .config and use
channel=0 (or channel=acs_survey) in hostapd.conf.

For more details see wiki page [1] or comments in src/ap/acs.c.

[1]: http://wireless.kernel.org/en/users/Documentation/acs

Signed-hostap: Michal Kazior <michal.kazior@tieto.com>

diff --git a/hostapd/Makefile b/hostapd/Makefile
index a30a24427c8b5802971e57a33996e0feefa610ee..fda4e4e35db21260a5744c4ad44cbbf75a18549b 100644 (file)
--- a/hostapd/Makefile
+++ b/hostapd/Makefile
@@ -817,6 +817,12 @@ else
 OBJS_c += ../src/utils/edit_simple.o
 endif
 
+ifdef CONFIG_ACS
+CFLAGS += -DCONFIG_ACS
+OBJS += ../src/ap/acs.o
+LIBS += -lm
+endif
+
 ifdef CONFIG_NO_STDOUT_DEBUG
 CFLAGS += -DCONFIG_NO_STDOUT_DEBUG
 endif

diff --git a/hostapd/config_file.c b/hostapd/config_file.c
index e9d324f9aeeef0f65212cdfbd827219757198271..a420c882c48412157a689c6db20b5856ed0906f2 100644 (file)
--- a/hostapd/config_file.c
+++ b/hostapd/config_file.c
@@ -2311,7 +2311,15 @@ static int hostapd_config_fill(struct hostapd_config *conf,
                                errors++;
                        }
                } else if (os_strcmp(buf, "channel") == 0) {
-                       conf->channel = atoi(pos);
+                       if (os_strcmp(pos, "acs_survey") == 0) {
+#ifndef CONFIG_ACS
+                               wpa_printf(MSG_ERROR, "Line %d: tries to enable ACS but CONFIG_ACS disabled",
+                                          line);
+                               errors++;
+#endif /* CONFIG_ACS */
+                               conf->channel = 0;
+                       } else
+                               conf->channel = atoi(pos);
                } else if (os_strcmp(buf, "beacon_int") == 0) {
                        int val = atoi(pos);
                        /* MIB defines range as 1..65535, but very small values
@@ -2326,6 +2334,16 @@ static int hostapd_config_fill(struct hostapd_config *conf,
                                errors++;
                        } else
                                conf->beacon_int = val;
+#ifdef CONFIG_ACS
+               } else if (os_strcmp(buf, "acs_num_scans") == 0) {
+                       int val = atoi(pos);
+                       if (val <= 0 || val > 100) {
+                               wpa_printf(MSG_ERROR, "Line %d: invalid acs_num_scans %d (expected 1..100)",
+                                          line, val);
+                               errors++;
+                       } else
+                               conf->acs_num_scans = val;
+#endif /* CONFIG_ACS */
                } else if (os_strcmp(buf, "dtim_period") == 0) {
                        bss->dtim_period = atoi(pos);
                        if (bss->dtim_period < 1 || bss->dtim_period > 255) {

diff --git a/hostapd/defconfig b/hostapd/defconfig
index c288f4661599d136f5a9b1c9e803f36ddaabaf20..2dd6fc824a5d791df97a0365526c441bc9deb8e9 100644 (file)
--- a/hostapd/defconfig
+++ b/hostapd/defconfig
@@ -278,3 +278,27 @@ CONFIG_IPV6=y
 # certain percentage of probe requests or auth/(re)assoc frames.
 #
 #CONFIG_TESTING_OPTIONS=y
+
+# Automatic Channel Selection
+# This will allow hostapd to pick the channel automatically when channel is set
+# to "acs_survey" or "0". Eventually, other ACS algorithms can be added in
+# similar way.
+#
+# Automatic selection is currently only done through initialization, later on
+# we hope to do background checks to keep us moving to more ideal channels as
+# time goes by. ACS is currently only supported through the nl80211 driver and
+# your driver must have survey dump capability that is filled by the driver
+# during scanning.
+#
+# You can customize the ACS survey algorithm with the hostapd.conf variable
+# acs_num_scans.
+#
+# Supported ACS drivers:
+# * ath9k
+# * ath5k
+# * ath10k
+#
+# For more details refer to:
+# http://wireless.kernel.org/en/users/Documentation/acs
+#
+#CONFIG_ACS=y

diff --git a/hostapd/hostapd.conf b/hostapd/hostapd.conf
index c46dff5d76dcc9af7a82d1cd7f71e11c7c80ac3d..45897ed932b2918764c52524a9f7a7829bfedc71 100644 (file)
--- a/hostapd/hostapd.conf
+++ b/hostapd/hostapd.conf
@@ -121,8 +121,28 @@ hw_mode=g
 # (default: 0, i.e., not set)
 # Please note that some drivers do not use this value from hostapd and the
 # channel will need to be configured separately with iwconfig.
+#
+# If CONFIG_ACS build option is enabled, the channel can be selected
+# automatically at run time by setting channel=acs_survey or channel=0, both of
+# which will enable the ACS survey based algorithm.
 channel=1
 
+# ACS tuning - Automatic Channel Selection
+# See: http://wireless.kernel.org/en/users/Documentation/acs
+#
+# You can customize the ACS survey algorithm with following variables:
+#
+# acs_num_scans requirement is 1..100 - number of scans to be performed that
+# are used to trigger survey data gathering of an underlying device driver.
+# Scans are passive and typically take a little over 100ms (depending on the
+# driver) on each available channel for given hw_mode. Increasing this value
+# means sacrificing startup time and gathering more data wrt channel
+# interference that may help choosing a better channel. This can also help fine
+# tune the ACS scan time in case a driver has different scan dwell times.
+#
+# Defaults:
+#acs_num_scans=5
+
 # Beacon interval in kus (1.024 ms) (default: 100; range 15..65535)
 beacon_int=100
 

diff --git a/src/ap/acs.c b/src/ap/acs.c
new file mode 100644 (file)
index 0000000..d5e3f59
--- /dev/null
+++ b/src/ap/acs.c
@@ -0,0 +1,770 @@
+/*
+ * ACS - Automatic Channel Selection module
+ * Copyright (c) 2011, Atheros Communications
+ * Copyright (c) 2013, Qualcomm Atheros, Inc.
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#include "utils/includes.h"
+#include <math.h>
+
+#include "utils/common.h"
+#include "utils/list.h"
+#include "common/ieee802_11_defs.h"
+#include "drivers/driver.h"
+#include "hostapd.h"
+#include "ap_drv_ops.h"
+#include "ap_config.h"
+#include "hw_features.h"
+#include "acs.h"
+
+/*
+ * Automatic Channel Selection
+ * ===========================
+ *
+ * More info at
+ * ------------
+ * http://wireless.kernel.org/en/users/Documentation/acs
+ *
+ * How to use
+ * ----------
+ * - make sure you have CONFIG_ACS=y in hostapd's .config
+ * - use channel=0 or channel=acs to enable ACS
+ *
+ * How does it work
+ * ----------------
+ * 1. passive scans are used to collect survey data
+ *    (it is assumed that scan trigger collection of survey data in driver)
+ * 2. interference factor is calculated for each channel
+ * 3. ideal channel is picked depending on channel width by using adjacent
+ *    channel interference factors
+ *
+ * Known limitations
+ * -----------------
+ * - Current implementation depends heavily on the amount of time willing to
+ *   spend gathering survey data during hostapd startup. Short traffic bursts
+ *   may be missed and a suboptimal channel may be picked.
+ * - Ideal channel may end up overlapping a channel with 40 MHz intolerant BSS
+ *
+ * Todo / Ideas
+ * ------------
+ * - implement other interference computation methods
+ *   - BSS/RSSI based
+ *   - spectral scan based
+ *   (should be possibly to hook this up with current ACS scans)
+ * - add wpa_supplicant support (for P2P)
+ * - collect a histogram of interference over time allowing more educated
+ *   guess about an ideal channel (perhaps CSA could be used to migrate AP to a
+ *   new "better" channel while running)
+ * - include neighboring BSS scan to avoid conflicts with 40 MHz intolerant BSSs
+ *   when choosing the ideal channel
+ *
+ * Survey interference factor implementation details
+ * -------------------------------------------------
+ * Generic interference_factor in struct hostapd_channel_data is used.
+ *
+ * The survey interference factor is defined as the ratio of the
+ * observed busy time over the time we spent on the channel,
+ * this value is then amplified by the observed noise floor on
+ * the channel in comparison to the lowest noise floor observed
+ * on the entire band.
+ *
+ * This corresponds to:
+ * ---
+ * (busy time - tx time) / (active time - tx time) * 2^(chan_nf + band_min_nf)
+ * ---
+ *
+ * The coefficient of 2 reflects the way power in "far-field"
+ * radiation decreases as the square of distance from the antenna [1].
+ * What this does is it decreases the observed busy time ratio if the
+ * noise observed was low but increases it if the noise was high,
+ * proportionally to the way "far field" radiation changes over
+ * distance.
+ *
+ * If channel busy time is not available the fallback is to use channel RX time.
+ *
+ * Since noise floor is in dBm it is necessary to convert it into Watts so that
+ * combined channel interference (e.g., HT40, which uses two channels) can be
+ * calculated easily.
+ * ---
+ * (busy time - tx time) / (active time - tx time) *
+ *    2^(10^(chan_nf/10) + 10^(band_min_nf/10))
+ * ---
+ *
+ * However to account for cases where busy/rx time is 0 (channel load is then
+ * 0%) channel noise floor signal power is combined into the equation so a
+ * channel with lower noise floor is preferred. The equation becomes:
+ * ---
+ * 10^(chan_nf/5) + (busy time - tx time) / (active time - tx time) *
+ *    2^(10^(chan_nf/10) + 10^(band_min_nf/10))
+ * ---
+ *
+ * All this "interference factor" is purely subjective and only time
+ * will tell how usable this is. By using the minimum noise floor we
+ * remove any possible issues due to card calibration. The computation
+ * of the interference factor then is dependent on what the card itself
+ * picks up as the minimum noise, not an actual real possible card
+ * noise value.
+ *
+ * Total interference computation details
+ * --------------------------------------
+ * The above channel interference factor is calculated with no respect to
+ * target operational bandwidth.
+ *
+ * To find an ideal channel the above data is combined by taking into account
+ * the target operational bandwidth and selected band. E.g., on 2.4 GHz channels
+ * overlap with 20 MHz bandwidth, but there is no overlap for 20 MHz bandwidth
+ * on 5 GHz.
+ *
+ * Each valid and possible channel spec (i.e., channel + width) is taken and its
+ * interference factor is computed by summing up interferences of each channel
+ * it overlaps. The one with least total interference is picked up.
+ *
+ * Note: This implies base channel interference factor must be non-negative
+ * allowing easy summing up.
+ *
+ * Example ACS analysis printout
+ * -----------------------------
+ *
+ * ACS: Trying survey-based ACS
+ * ACS: Survey analysis for channel 1 (2412 MHz)
+ * ACS:  1: min_nf=-113 interference_factor=0.0802469 nf=-113 time=162 busy=0 rx=13
+ * ACS:  2: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
+ * ACS:  3: min_nf=-113 interference_factor=0.0679012 nf=-113 time=162 busy=0 rx=11
+ * ACS:  4: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
+ * ACS:  5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
+ * ACS:  * interference factor average: 0.0557166
+ * ACS: Survey analysis for channel 2 (2417 MHz)
+ * ACS:  1: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
+ * ACS:  2: min_nf=-113 interference_factor=0.0246914 nf=-113 time=162 busy=0 rx=4
+ * ACS:  3: min_nf=-113 interference_factor=0.037037 nf=-113 time=162 busy=0 rx=6
+ * ACS:  4: min_nf=-113 interference_factor=0.149068 nf=-113 time=161 busy=0 rx=24
+ * ACS:  5: min_nf=-113 interference_factor=0.0248447 nf=-113 time=161 busy=0 rx=4
+ * ACS:  * interference factor average: 0.050832
+ * ACS: Survey analysis for channel 3 (2422 MHz)
+ * ACS:  1: min_nf=-113 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
+ * ACS:  2: min_nf=-113 interference_factor=0.0185185 nf=-113 time=162 busy=0 rx=3
+ * ACS:  3: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
+ * ACS:  4: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
+ * ACS:  5: min_nf=-113 interference_factor=0.0186335 nf=-113 time=161 busy=0 rx=3
+ * ACS:  * interference factor average: 0.0148838
+ * ACS: Survey analysis for channel 4 (2427 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
+ * ACS:  2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
+ * ACS:  3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
+ * ACS:  4: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
+ * ACS:  5: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
+ * ACS:  * interference factor average: 0.0160801
+ * ACS: Survey analysis for channel 5 (2432 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=0.409938 nf=-113 time=161 busy=0 rx=66
+ * ACS:  2: min_nf=-114 interference_factor=0.0432099 nf=-113 time=162 busy=0 rx=7
+ * ACS:  3: min_nf=-114 interference_factor=0.0124224 nf=-113 time=161 busy=0 rx=2
+ * ACS:  4: min_nf=-114 interference_factor=0.677019 nf=-113 time=161 busy=0 rx=109
+ * ACS:  5: min_nf=-114 interference_factor=0.0186335 nf=-114 time=161 busy=0 rx=3
+ * ACS:  * interference factor average: 0.232244
+ * ACS: Survey analysis for channel 6 (2437 MHz)
+ * ACS:  1: min_nf=-113 interference_factor=0.552795 nf=-113 time=161 busy=0 rx=89
+ * ACS:  2: min_nf=-113 interference_factor=0.0807453 nf=-112 time=161 busy=0 rx=13
+ * ACS:  3: min_nf=-113 interference_factor=0.0310559 nf=-113 time=161 busy=0 rx=5
+ * ACS:  4: min_nf=-113 interference_factor=0.434783 nf=-112 time=161 busy=0 rx=70
+ * ACS:  5: min_nf=-113 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
+ * ACS:  * interference factor average: 0.232298
+ * ACS: Survey analysis for channel 7 (2442 MHz)
+ * ACS:  1: min_nf=-113 interference_factor=0.440994 nf=-112 time=161 busy=0 rx=71
+ * ACS:  2: min_nf=-113 interference_factor=0.385093 nf=-113 time=161 busy=0 rx=62
+ * ACS:  3: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
+ * ACS:  4: min_nf=-113 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
+ * ACS:  5: min_nf=-113 interference_factor=0.0745342 nf=-113 time=161 busy=0 rx=12
+ * ACS:  * interference factor average: 0.195031
+ * ACS: Survey analysis for channel 8 (2447 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=0.0496894 nf=-112 time=161 busy=0 rx=8
+ * ACS:  2: min_nf=-114 interference_factor=0.0496894 nf=-114 time=161 busy=0 rx=8
+ * ACS:  3: min_nf=-114 interference_factor=0.0372671 nf=-113 time=161 busy=0 rx=6
+ * ACS:  4: min_nf=-114 interference_factor=0.12963 nf=-113 time=162 busy=0 rx=21
+ * ACS:  5: min_nf=-114 interference_factor=0.166667 nf=-114 time=162 busy=0 rx=27
+ * ACS:  * interference factor average: 0.0865885
+ * ACS: Survey analysis for channel 9 (2452 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=0.0124224 nf=-114 time=161 busy=0 rx=2
+ * ACS:  2: min_nf=-114 interference_factor=0.0310559 nf=-114 time=161 busy=0 rx=5
+ * ACS:  3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
+ * ACS:  4: min_nf=-114 interference_factor=0.00617284 nf=-114 time=162 busy=0 rx=1
+ * ACS:  5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
+ * ACS:  * interference factor average: 0.00993022
+ * ACS: Survey analysis for channel 10 (2457 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
+ * ACS:  2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
+ * ACS:  3: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
+ * ACS:  4: min_nf=-114 interference_factor=0.0493827 nf=-114 time=162 busy=0 rx=8
+ * ACS:  5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
+ * ACS:  * interference factor average: 0.0136033
+ * ACS: Survey analysis for channel 11 (2462 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=161 busy=0 rx=0
+ * ACS:  2: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
+ * ACS:  3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=161 busy=0 rx=0
+ * ACS:  4: min_nf=-114 interference_factor=0.0432099 nf=-114 time=162 busy=0 rx=7
+ * ACS:  5: min_nf=-114 interference_factor=0.0925926 nf=-114 time=162 busy=0 rx=15
+ * ACS:  * interference factor average: 0.0271605
+ * ACS: Survey analysis for channel 12 (2467 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=0.0621118 nf=-113 time=161 busy=0 rx=10
+ * ACS:  2: min_nf=-114 interference_factor=0.00621118 nf=-114 time=161 busy=0 rx=1
+ * ACS:  3: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
+ * ACS:  4: min_nf=-114 interference_factor=2.51189e-23 nf=-113 time=162 busy=0 rx=0
+ * ACS:  5: min_nf=-114 interference_factor=0.00617284 nf=-113 time=162 busy=0 rx=1
+ * ACS:  * interference factor average: 0.0148992
+ * ACS: Survey analysis for channel 13 (2472 MHz)
+ * ACS:  1: min_nf=-114 interference_factor=0.0745342 nf=-114 time=161 busy=0 rx=12
+ * ACS:  2: min_nf=-114 interference_factor=0.0555556 nf=-114 time=162 busy=0 rx=9
+ * ACS:  3: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
+ * ACS:  4: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
+ * ACS:  5: min_nf=-114 interference_factor=1.58489e-23 nf=-114 time=162 busy=0 rx=0
+ * ACS:  * interference factor average: 0.0260179
+ * ACS: Survey analysis for selected bandwidth 20MHz
+ * ACS:  * channel 1: total interference = 0.121432
+ * ACS:  * channel 2: total interference = 0.137512
+ * ACS:  * channel 3: total interference = 0.369757
+ * ACS:  * channel 4: total interference = 0.546338
+ * ACS:  * channel 5: total interference = 0.690538
+ * ACS:  * channel 6: total interference = 0.762242
+ * ACS:  * channel 7: total interference = 0.756092
+ * ACS:  * channel 8: total interference = 0.537451
+ * ACS:  * channel 9: total interference = 0.332313
+ * ACS:  * channel 10: total interference = 0.152182
+ * ACS:  * channel 11: total interference = 0.0916111
+ * ACS:  * channel 12: total interference = 0.0816809
+ * ACS:  * channel 13: total interference = 0.0680776
+ * ACS: Ideal channel is 13 (2472 MHz) with total interference factor of 0.0680776
+ *
+ * [1] http://en.wikipedia.org/wiki/Near_and_far_field
+ */
+
+
+static int acs_request_scan(struct hostapd_iface *iface);
+
+
+static void acs_clean_chan_surveys(struct hostapd_channel_data *chan)
+{
+       struct freq_survey *survey, *tmp;
+
+       if (dl_list_empty(&chan->survey_list))
+               return;
+
+       dl_list_for_each_safe(survey, tmp, &chan->survey_list,
+                             struct freq_survey, list) {
+               dl_list_del(&survey->list);
+               os_free(survey);
+       }
+}
+
+
+static void acs_cleanup(struct hostapd_iface *iface)
+{
+       int i;
+       struct hostapd_channel_data *chan;
+
+       for (i = 0; i < iface->current_mode->num_channels; i++) {
+               chan = &iface->current_mode->channels[i];
+
+               if (chan->flag & HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED)
+                       acs_clean_chan_surveys(chan);
+
+               dl_list_init(&chan->survey_list);
+               chan->flag |= HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED;
+               chan->min_nf = 0;
+       }
+
+       iface->chans_surveyed = 0;
+       iface->acs_num_completed_scans = 0;
+}
+
+
+void acs_fail(struct hostapd_iface *iface)
+{
+       wpa_printf(MSG_ERROR, "ACS: Failed to start");
+       acs_cleanup(iface);
+}
+
+
+static long double
+acs_survey_interference_factor(struct freq_survey *survey, s8 min_nf)
+{
+       long double factor, busy, total;
+
+       if (survey->filled & SURVEY_HAS_CHAN_TIME_BUSY)
+               busy = survey->channel_time_busy;
+       else if (survey->filled & SURVEY_HAS_CHAN_TIME_RX)
+               busy = survey->channel_time_rx;
+       else {
+               /* This shouldn't really happen as survey data is checked in
+                * acs_sanity_check() */
+               wpa_printf(MSG_ERROR, "ACS: Survey data missing");
+               return 0;
+       }
+
+       total = survey->channel_time;
+
+       if (survey->filled & SURVEY_HAS_CHAN_TIME_TX) {
+               busy -= survey->channel_time_tx;
+               total -= survey->channel_time_tx;
+       }
+
+       /* TODO: figure out the best multiplier for noise floor base */
+       factor = pow(10, survey->nf / 5.0L) +
+               (busy / total) *
+               pow(2, pow(10, (long double) survey->nf / 10.0L) -
+                   pow(10, (long double) min_nf / 10.0L));
+
+       return factor;
+}
+
+
+static void
+acs_survey_chan_interference_factor(struct hostapd_iface *iface,
+                                   struct hostapd_channel_data *chan)
+{
+       struct freq_survey *survey;
+       unsigned int i = 0;
+       long double int_factor = 0;
+
+       if (dl_list_empty(&chan->survey_list))
+               return;
+
+       if (chan->flag & HOSTAPD_CHAN_DISABLED)
+               return;
+
+       chan->interference_factor = 0;
+
+       dl_list_for_each(survey, &chan->survey_list, struct freq_survey, list)
+       {
+               int_factor = acs_survey_interference_factor(survey,
+                                                           iface->lowest_nf);
+               chan->interference_factor += int_factor;
+               wpa_printf(MSG_DEBUG, "ACS: %d: min_nf=%d interference_factor=%Lg nf=%d time=%lu busy=%lu rx=%lu",
+                          ++i, chan->min_nf, int_factor,
+                          survey->nf, (unsigned long) survey->channel_time,
+                          (unsigned long) survey->channel_time_busy,
+                          (unsigned long) survey->channel_time_rx);
+       }
+
+       chan->interference_factor = chan->interference_factor /
+               dl_list_len(&chan->survey_list);
+}
+
+
+static int acs_usable_chan(struct hostapd_channel_data *chan)
+{
+       if (dl_list_empty(&chan->survey_list))
+               return 0;
+       if (chan->flag & HOSTAPD_CHAN_DISABLED)
+               return 0;
+       return 1;
+}
+
+
+static int acs_usable_ht40_chan(struct hostapd_channel_data *chan)
+{
+       const int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149,
+                               157, 184, 192 };
+       unsigned int i;
+
+       for (i = 0; i < sizeof(allowed) / sizeof(allowed[0]); i++)
+               if (chan->chan == allowed[i])
+                       return 1;
+
+       return 0;
+}
+
+
+static int acs_survey_is_sufficient(struct freq_survey *survey)
+{
+       if (!(survey->filled & SURVEY_HAS_NF)) {
+               wpa_printf(MSG_ERROR, "ACS: Survey is missing noise floor");
+               return 0;
+       }
+
+       if (!(survey->filled & SURVEY_HAS_CHAN_TIME)) {
+               wpa_printf(MSG_ERROR, "ACS: Survey is missing channel time");
+               return 0;
+       }
+
+       if (!(survey->filled & SURVEY_HAS_CHAN_TIME_BUSY) &&
+           !(survey->filled & SURVEY_HAS_CHAN_TIME_RX)) {
+               wpa_printf(MSG_ERROR, "ACS: Survey is missing RX and busy time (at least one is required)");
+               return 0;
+       }
+
+       return 1;
+}
+
+
+static int acs_surveys_are_sufficient(struct hostapd_iface *iface)
+{
+       int i;
+       struct hostapd_channel_data *chan;
+       struct freq_survey *survey;
+
+       for (i = 0; i < iface->current_mode->num_channels; i++) {
+               chan = &iface->current_mode->channels[i];
+               if (chan->flag & HOSTAPD_CHAN_DISABLED)
+                       continue;
+
+               dl_list_for_each(survey, &chan->survey_list,
+                                struct freq_survey, list)
+               {
+                       if (!acs_survey_is_sufficient(survey)) {
+                               wpa_printf(MSG_ERROR, "ACS: Channel %d has insufficient survey data",
+                                          chan->chan);
+                               return 0;
+                       }
+               }
+       }
+
+       return 1;
+}
+
+
+static void acs_survey_all_chans_intereference_factor(
+       struct hostapd_iface *iface)
+{
+       int i;
+       struct hostapd_channel_data *chan;
+
+       for (i = 0; i < iface->current_mode->num_channels; i++) {
+               chan = &iface->current_mode->channels[i];
+
+               if (!acs_usable_chan(chan))
+                       continue;
+
+               wpa_printf(MSG_DEBUG, "ACS: Survey analysis for channel %d (%d MHz)",
+                          chan->chan, chan->freq);
+
+               acs_survey_chan_interference_factor(iface, chan);
+
+               wpa_printf(MSG_DEBUG, "ACS:  * interference factor average: %Lg",
+                          chan->interference_factor);
+       }
+}
+
+
+static struct hostapd_channel_data *acs_find_chan(struct hostapd_iface *iface,
+                                                 int freq)
+{
+       struct hostapd_channel_data *chan;
+       int i;
+
+       for (i = 0; i < iface->current_mode->num_channels; i++) {
+               chan = &iface->current_mode->channels[i];
+
+               if (!acs_usable_chan(chan))
+                       continue;
+
+               if (chan->freq == freq)
+                       return chan;
+       }
+
+       return NULL;
+}
+
+
+/*
+ * At this point it's assumed chan->interface_factor has been computed.
+ * This function should be reusable regardless of interference computation
+ * option (survey, BSS, spectral, ...). chan->interference factor must be
+ * summable (i.e., must be always greater than zero).
+ */
+static struct hostapd_channel_data *
+acs_find_ideal_chan(struct hostapd_iface *iface)
+{
+       struct hostapd_channel_data *chan, *adj_chan, *ideal_chan = NULL;
+       long double factor, ideal_factor = 0;
+       int i, j;
+       int n_chans = 1;
+
+       /* TODO: HT40- support */
+
+       if (iface->conf->ieee80211n &&
+           iface->conf->secondary_channel == -1) {
+               wpa_printf(MSG_ERROR, "ACS: HT40- is not supported yet. Please try HT40+");
+               return NULL;
+       }
+
+       if (iface->conf->ieee80211n &&
+           iface->conf->secondary_channel)
+               n_chans = 2;
+
+       if (iface->conf->ieee80211ac &&
+           iface->conf->vht_oper_chwidth == 1)
+               n_chans = 4;
+
+       /* TODO: VHT80+80, VHT160. Update acs_adjust_vht_center_freq() too. */
+
+       wpa_printf(MSG_DEBUG, "ACS: Survey analysis for selected bandwidth %d MHz",
+                  n_chans == 1 ? 20 :
+                  n_chans == 2 ? 40 :
+                  n_chans == 4 ? 80 :
+                  -1);
+
+       for (i = 0; i < iface->current_mode->num_channels; i++) {
+               chan = &iface->current_mode->channels[i];
+
+               if (!acs_usable_chan(chan))
+                       continue;
+
+               /* HT40 on 5 GHz has a limited set of primary channels as per
+                * 11n Annex J */
+               if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211A &&
+                   iface->conf->ieee80211n &&
+                   iface->conf->secondary_channel &&
+                   !acs_usable_ht40_chan(chan)) {
+                       wpa_printf(MSG_DEBUG, "ACS: Channel %d: not allowed as primary channel for HT40",
+                                  chan->chan);
+                       continue;
+               }
+
+               factor = chan->interference_factor;
+
+               for (j = 1; j < n_chans; j++) {
+                       adj_chan = acs_find_chan(iface, chan->freq + (j * 20));
+                       if (!adj_chan)
+                               break;
+
+                       factor += adj_chan->interference_factor;
+               }
+
+               if (j != n_chans) {
+                       wpa_printf(MSG_DEBUG, "ACS: Channel %d: not enough bandwidth",
+                                  chan->chan);
+                       continue;
+               }
+
+               /* 2.4 GHz has overlapping 20 MHz channels. Include adjacent
+                * channel interference factor. */
+               if (iface->current_mode->mode == HOSTAPD_MODE_IEEE80211B ||
+                   iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G) {
+                       for (j = 0; j < n_chans; j++) {
+                               /* TODO: perhaps a multiplier should be used
+                                * here? */
+
+                               adj_chan = acs_find_chan(iface, chan->freq +
+                                                        (j * 20) - 5);
+                               if (adj_chan)
+                                       factor += adj_chan->interference_factor;
+
+                               adj_chan = acs_find_chan(iface, chan->freq +
+                                                        (j * 20) - 10);
+                               if (adj_chan)
+                                       factor += adj_chan->interference_factor;
+
+                               adj_chan = acs_find_chan(iface, chan->freq +
+                                                        (j * 20) + 5);
+                               if (adj_chan)
+                                       factor += adj_chan->interference_factor;
+
+                               adj_chan = acs_find_chan(iface, chan->freq +
+                                                        (j * 20) + 10);
+                               if (adj_chan)
+                                       factor += adj_chan->interference_factor;
+                       }
+               }
+
+               wpa_printf(MSG_DEBUG, "ACS:  * channel %d: total interference = %Lg",
+                          chan->chan, factor);
+
+               if (!ideal_chan || factor < ideal_factor) {
+                       ideal_factor = factor;
+                       ideal_chan = chan;
+               }
+       }
+
+       if (ideal_chan)
+               wpa_printf(MSG_DEBUG, "ACS: Ideal channel is %d (%d MHz) with total interference factor of %Lg",
+                          ideal_chan->chan, ideal_chan->freq, ideal_factor);
+
+       return ideal_chan;
+}
+
+
+static void acs_adjust_vht_center_freq(struct hostapd_iface *iface)
+{
+       wpa_printf(MSG_DEBUG, "ACS: Adjusting VHT center frequency");
+
+       switch (iface->conf->vht_oper_chwidth) {
+       case VHT_CHANWIDTH_USE_HT:
+               iface->conf->vht_oper_centr_freq_seg0_idx =
+                       iface->conf->channel + 2;
+               break;
+       case VHT_CHANWIDTH_80MHZ:
+               iface->conf->vht_oper_centr_freq_seg0_idx =
+                       iface->conf->channel + 6;
+               break;
+       default:
+               /* TODO: How can this be calculated? Adjust
+                * acs_find_ideal_chan() */
+               wpa_printf(MSG_INFO, "ACS: Only VHT20/40/80 is supported now");
+               break;
+       }
+}
+
+
+static int acs_study_survey_based(struct hostapd_iface *iface)
+{
+       wpa_printf(MSG_DEBUG, "ACS: Trying survey-based ACS");
+
+       if (!iface->chans_surveyed) {
+               wpa_printf(MSG_ERROR, "ACS: Unable to collect survey data");
+               return -1;
+       }
+
+       if (!acs_surveys_are_sufficient(iface)) {
+               wpa_printf(MSG_ERROR, "ACS: Surveys have insufficient data");
+               return -1;
+       }
+
+       acs_survey_all_chans_intereference_factor(iface);
+       return 0;
+}
+
+
+static int acs_study_options(struct hostapd_iface *iface)
+{
+       int err;
+
+       err = acs_study_survey_based(iface);
+       if (err == 0)
+               return 0;
+
+       /* TODO: If no surveys are available/sufficient this is a good
+        * place to fallback to BSS-based ACS */
+
+       return -1;
+}
+
+
+static void acs_study(struct hostapd_iface *iface)
+{
+       struct hostapd_channel_data *ideal_chan;
+       int err;
+
+       err = acs_study_options(iface);
+       if (err < 0) {
+               wpa_printf(MSG_ERROR, "ACS: All study options have failed");
+               goto fail;
+       }
+
+       ideal_chan = acs_find_ideal_chan(iface);
+       if (!ideal_chan) {
+               wpa_printf(MSG_ERROR, "ACS: Failed to compute ideal channel");
+               goto fail;
+       }
+
+       iface->conf->channel = ideal_chan->chan;
+
+       if (iface->conf->ieee80211ac)
+               acs_adjust_vht_center_freq(iface);
+
+       /*
+        * hostapd_setup_interface_complete() will return -1 on failure,
+        * 0 on success and 0 is HOSTAPD_CHAN_VALID :)
+        */
+       switch (hostapd_acs_completed(iface)) {
+       case HOSTAPD_CHAN_VALID:
+               acs_cleanup(iface);
+               return;
+       case HOSTAPD_CHAN_INVALID:
+       case HOSTAPD_CHAN_ACS:
+       default:
+               /* This can possibly happen if channel parameters (secondary
+                * channel, center frequencies) are misconfigured */
+               wpa_printf(MSG_ERROR, "ACS: Possibly channel configuration is invalid, please report this along with your config file.");
+               goto fail;
+       }
+
+fail:
+       acs_fail(iface);
+}
+
+
+static void acs_scan_complete(struct hostapd_iface *iface)
+{
+       int err;
+
+       iface->scan_cb = NULL;
+
+       wpa_printf(MSG_DEBUG, "ACS: Using survey based algorithm (acs_num_scans=%d)",
+                  iface->conf->acs_num_scans);
+
+       err = hostapd_drv_get_survey(iface->bss[0], 0);
+       if (err) {
+               wpa_printf(MSG_ERROR, "ACS: Failed to get survey data");
+               acs_fail(iface);
+       }
+
+       if (++iface->acs_num_completed_scans < iface->conf->acs_num_scans) {
+               err = acs_request_scan(iface);
+               if (err) {
+                       wpa_printf(MSG_ERROR, "ACS: Failed to request scan");
+                       acs_fail(iface);
+                       return;
+               }
+
+               return;
+       }
+
+       acs_study(iface);
+}
+
+
+static int acs_request_scan(struct hostapd_iface *iface)
+{
+       struct wpa_driver_scan_params params;
+       struct hostapd_channel_data *chan;
+       int i, *freq;
+
+       os_memset(&params, 0, sizeof(params));
+       params.freqs = os_calloc(iface->current_mode->num_channels + 1,
+                                sizeof(params.freqs[0]));
+       if (params.freqs == NULL)
+               return -1;
+
+       freq = params.freqs;
+       for (i = 0; i < iface->current_mode->num_channels; i++) {
+               chan = &iface->current_mode->channels[i];
+               if (chan->flag & HOSTAPD_CHAN_DISABLED)
+                       continue;
+
+               *freq++ = chan->freq;
+       }
+       *freq = 0;
+
+       iface->scan_cb = acs_scan_complete;
+
+       wpa_printf(MSG_DEBUG, "ACS: Scanning %d / %d",
+                  iface->acs_num_completed_scans + 1,
+                  iface->conf->acs_num_scans);
+
+       if (hostapd_driver_scan(iface->bss[0], &params) < 0) {
+               wpa_printf(MSG_ERROR, "ACS: Failed to request initial scan");
+               acs_cleanup(iface);
+               return -1;
+       }
+
+       os_free(params.freqs);
+       return 0;
+}
+
+
+enum hostapd_chan_status acs_init(struct hostapd_iface *iface)
+{
+       int err;
+
+       wpa_printf(MSG_INFO, "ACS: Automatic channel selection started, this may take a bit");
+
+       acs_cleanup(iface);
+
+       err = acs_request_scan(iface);
+       if (err < 0)
+               return HOSTAPD_CHAN_INVALID;
+
+       return HOSTAPD_CHAN_ACS;
+}

diff --git a/src/ap/acs.h b/src/ap/acs.h
new file mode 100644 (file)
index 0000000..0d1d0f1
--- /dev/null
+++ b/src/ap/acs.h
@@ -0,0 +1,28 @@
+/*
+ * ACS - Automatic Channel Selection module
+ * Copyright (c) 2011, Atheros Communications
+ * Copyright (c) 2013, Qualcomm Atheros, Inc.
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#ifndef ACS_H
+#define ACS_H
+
+#ifdef CONFIG_ACS
+
+enum hostapd_chan_status acs_init(struct hostapd_iface *iface);
+int hostapd_acs_completed(struct hostapd_iface *iface);
+
+#else /* CONFIG_ACS */
+
+static inline enum hostapd_chan_status acs_init(struct hostapd_iface *iface)
+{
+       wpa_printf(MSG_ERROR, "ACS was disabled on your build, rebuild hostapd with CONFIG_ACS=y or set channel");
+       return HOSTAPD_CHAN_INVALID;
+}
+
+#endif /* CONFIG_ACS */
+
+#endif /* ACS_H */

diff --git a/src/ap/ap_config.c b/src/ap/ap_config.c
index 54a2e75077b1c991e16256183076cc00d9602616..d869ebde516b414d18786d234dd4516b67c41005 100644 (file)
--- a/src/ap/ap_config.c
+++ b/src/ap/ap_config.c
@@ -171,6 +171,10 @@ struct hostapd_config * hostapd_config_defaults(void)
        conf->corrupt_gtk_rekey_mic_probability = 0.0d;
 #endif /* CONFIG_TESTING_OPTIONS */
 
+#ifdef CONFIG_ACS
+       conf->acs_num_scans = 5;
+#endif /* CONFIG_ACS */
+
        return conf;
 }
 

diff --git a/src/ap/ap_config.h b/src/ap/ap_config.h
index 9b87686e30cd19018f221ba43d71a160d6b94aaa..d5bfabceb9fe004fc205234e0d4b466337d0cc3f 100644 (file)
--- a/src/ap/ap_config.h
+++ b/src/ap/ap_config.h
@@ -532,6 +532,10 @@ struct hostapd_config {
        double ignore_reassoc_probability;
        double corrupt_gtk_rekey_mic_probability;
 #endif /* CONFIG_TESTING_OPTIONS */
+
+#ifdef CONFIG_ACS
+       unsigned int acs_num_scans;
+#endif /* CONFIG_ACS */
 };
 
 

diff --git a/src/ap/hostapd.c b/src/ap/hostapd.c
index 7925a3ebef2e03e404899943e9d9348c2afd3177..fd1ca2b39e505dec5228f738c163e1b8990aa48a 100644 (file)
--- a/src/ap/hostapd.c
+++ b/src/ap/hostapd.c
@@ -919,6 +919,10 @@ static int setup_interface(struct hostapd_iface *iface)
                                   "channel. (%d)", ret);
                        return -1;
                }
+               if (ret == 1) {
+                       wpa_printf(MSG_DEBUG, "Interface initialization will be completed in a callback (ACS)");
+                       return 0;
+               }
                ret = hostapd_check_ht_capab(iface);
                if (ret < 0)
                        return -1;

diff --git a/src/ap/hostapd.h b/src/ap/hostapd.h
index 673dd34ae8a49680033faa20082b266bd4c7c6ad..cae47563da775f3ba42074160ac5db4b85b166f5 100644 (file)
--- a/src/ap/hostapd.h
+++ b/src/ap/hostapd.h
@@ -310,6 +310,10 @@ struct hostapd_iface {
        /* lowest observed noise floor in dBm */
        s8 lowest_nf;
 
+#ifdef CONFIG_ACS
+       unsigned int acs_num_completed_scans;
+#endif /* CONFIG_ACS */
+
        void (*scan_cb)(struct hostapd_iface *iface);
 };
 

diff --git a/src/ap/hw_features.c b/src/ap/hw_features.c
index bf0dd953408c27bed5eaedd43fed4435a9e29e42..8a239f49f3df583abce93566ebc4c5f6a90ad35e 100644 (file)
--- a/src/ap/hw_features.c
+++ b/src/ap/hw_features.c
@@ -24,6 +24,7 @@
 #include "hostapd.h"
 #include "ap_config.h"
 #include "ap_drv_ops.h"
+#include "acs.h"
 #include "hw_features.h"
 
 
@@ -686,10 +687,18 @@ hostapd_check_chans(struct hostapd_iface *iface)
        }
 
        /*
-        * The user set channel=0 which is used to trigger ACS,
-        * which we do not yet support.
+        * The user set channel=0 or channel=acs_survey
+        * which is used to trigger ACS.
         */
-       return HOSTAPD_CHAN_INVALID;
+
+       switch (acs_init(iface)) {
+       case HOSTAPD_CHAN_ACS:
+               return HOSTAPD_CHAN_ACS;
+       case HOSTAPD_CHAN_VALID:
+       case HOSTAPD_CHAN_INVALID:
+       default:
+               return HOSTAPD_CHAN_INVALID;
+       }
 }
 
 
@@ -709,6 +718,36 @@ static void hostapd_notify_bad_chans(struct hostapd_iface *iface)
 }
 
 
+int hostapd_acs_completed(struct hostapd_iface *iface)
+{
+       int ret;
+
+       switch (hostapd_check_chans(iface)) {
+       case HOSTAPD_CHAN_VALID:
+               break;
+       case HOSTAPD_CHAN_ACS:
+               wpa_printf(MSG_ERROR, "ACS error - reported complete, but no result available");
+               hostapd_notify_bad_chans(iface);
+               return -1;
+       case HOSTAPD_CHAN_INVALID:
+       default:
+               wpa_printf(MSG_ERROR, "ACS picked unusable channels");
+               hostapd_notify_bad_chans(iface);
+               return -1;
+       }
+
+       ret = hostapd_check_ht_capab(iface);
+       if (ret < 0)
+               return -1;
+       if (ret == 1) {
+               wpa_printf(MSG_DEBUG, "Interface initialization will be completed in a callback");
+               return 0;
+       }
+
+       return hostapd_setup_interface_complete(iface, 0);
+}
+
+
 /**
  * hostapd_select_hw_mode - Select the hardware mode
  * @iface: Pointer to interface data.
@@ -747,7 +786,8 @@ int hostapd_select_hw_mode(struct hostapd_iface *iface)
        switch (hostapd_check_chans(iface)) {
        case HOSTAPD_CHAN_VALID:
                return 0;
-       case HOSTAPD_CHAN_ACS: /* ACS not supported yet */
+       case HOSTAPD_CHAN_ACS: /* ACS will run and later complete */
+               return 1;
        case HOSTAPD_CHAN_INVALID:
        default:
                hostapd_notify_bad_chans(iface);

diff --git a/src/drivers/driver.h b/src/drivers/driver.h
index 6fb05ac71c052a5aa9b818063391374ebbaad03c..97bd9c6716d4b65ac4bde4820afc54d41306817c 100644 (file)
--- a/src/drivers/driver.h
+++ b/src/drivers/driver.h
@@ -29,6 +29,7 @@
 #define HOSTAPD_CHAN_HT40PLUS 0x00000010
 #define HOSTAPD_CHAN_HT40MINUS 0x00000020
 #define HOSTAPD_CHAN_HT40 0x00000040
+#define HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED 0x00000080
 
 #define HOSTAPD_CHAN_DFS_UNKNOWN 0x00000000
 #define HOSTAPD_CHAN_DFS_USABLE 0x00000100
@@ -70,6 +71,15 @@ struct hostapd_channel_data {
         * surveyed channel data
         */
        s8 min_nf;
+
+#ifdef CONFIG_ACS
+       /**
+        * interference_factor - Computed interference factor on this
+        * channel (used internally in src/ap/acs.c; driver wrappers do not
+        * need to set this)
+        */
+       long double interference_factor;
+#endif /* CONFIG_ACS */
 };
 
 #define HOSTAPD_MODE_FLAG_HT_INFO_KNOWN BIT(0)