[thirdparty/hostap.git] / src / common / hw_features_common.c

/*
 * Common hostapd/wpa_supplicant HW features
 * Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi>
 * Copyright (c) 2015, Qualcomm Atheros, Inc.
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "includes.h"

#include "common.h"
#include "defs.h"
#include "ieee802_11_defs.h"
#include "ieee802_11_common.h"
#include "hw_features_common.h"


struct hostapd_channel_data * hw_get_channel_chan(struct hostapd_hw_modes *mode,
						  int chan, int *freq)
{
	int i;

	if (freq)
		*freq = 0;

	if (!mode)
		return NULL;

	for (i = 0; i < mode->num_channels; i++) {
		struct hostapd_channel_data *ch = &mode->channels[i];
		if (ch->chan == chan) {
			if (freq)
				*freq = ch->freq;
			return ch;
		}
	}

	return NULL;
}


struct hostapd_channel_data * hw_get_channel_freq(struct hostapd_hw_modes *mode,
						  int freq, int *chan)
{
	int i;

	if (chan)
		*chan = 0;

	if (!mode)
		return NULL;

	for (i = 0; i < mode->num_channels; i++) {
		struct hostapd_channel_data *ch = &mode->channels[i];
		if (ch->freq == freq) {
			if (chan)
				*chan = ch->chan;
			return ch;
		}
	}

	return NULL;
}


int hw_get_freq(struct hostapd_hw_modes *mode, int chan)
{
	int freq;

	hw_get_channel_chan(mode, chan, &freq);

	return freq;
}


int hw_get_chan(struct hostapd_hw_modes *mode, int freq)
{
	int chan;

	hw_get_channel_freq(mode, freq, &chan);

	return chan;
}


int allowed_ht40_channel_pair(struct hostapd_hw_modes *mode, int pri_chan,
			      int sec_chan)
{
	int ok, first;
	int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 140,
			  149, 157, 165, 184, 192 };
	size_t k;
	struct hostapd_channel_data *p_chan, *s_chan;
	const int ht40_plus = pri_chan < sec_chan;

	p_chan = hw_get_channel_chan(mode, pri_chan, NULL);
	if (!p_chan)
		return 0;

	if (pri_chan == sec_chan || !sec_chan) {
		if (chan_pri_allowed(p_chan))
			return 1; /* HT40 not used */

		wpa_printf(MSG_ERROR, "Channel %d is not allowed as primary",
			   pri_chan);
		return 0;
	}

	s_chan = hw_get_channel_chan(mode, sec_chan, NULL);
	if (!s_chan)
		return 0;

	wpa_printf(MSG_DEBUG,
		   "HT40: control channel: %d  secondary channel: %d",
		   pri_chan, sec_chan);

	/* Verify that HT40 secondary channel is an allowed 20 MHz
	 * channel */
	if ((s_chan->flag & HOSTAPD_CHAN_DISABLED) ||
	    (ht40_plus && !(p_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40P)) ||
	    (!ht40_plus && !(p_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40M))) {
		wpa_printf(MSG_ERROR, "HT40 secondary channel %d not allowed",
			   sec_chan);
		return 0;
	}

	/*
	 * Verify that HT40 primary,secondary channel pair is allowed per
	 * IEEE 802.11n Annex J. This is only needed for 5 GHz band since
	 * 2.4 GHz rules allow all cases where the secondary channel fits into
	 * the list of allowed channels (already checked above).
	 */
	if (mode->mode != HOSTAPD_MODE_IEEE80211A)
		return 1;

	first = pri_chan < sec_chan ? pri_chan : sec_chan;

	ok = 0;
	for (k = 0; k < ARRAY_SIZE(allowed); k++) {
		if (first == allowed[k]) {
			ok = 1;
			break;
		}
	}
	if (!ok) {
		wpa_printf(MSG_ERROR, "HT40 channel pair (%d, %d) not allowed",
			   pri_chan, sec_chan);
		return 0;
	}

	return 1;
}


void get_pri_sec_chan(struct wpa_scan_res *bss, int *pri_chan, int *sec_chan)
{
	struct ieee80211_ht_operation *oper;
	struct ieee802_11_elems elems;

	*pri_chan = *sec_chan = 0;

	ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0);
	if (elems.ht_operation) {
		oper = (struct ieee80211_ht_operation *) elems.ht_operation;
		*pri_chan = oper->primary_chan;
		if (oper->ht_param & HT_INFO_HT_PARAM_STA_CHNL_WIDTH) {
			int sec = oper->ht_param &
				HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK;
			if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_ABOVE)
				*sec_chan = *pri_chan + 4;
			else if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_BELOW)
				*sec_chan = *pri_chan - 4;
		}
	}
}


int check_40mhz_5g(struct hostapd_hw_modes *mode,
		   struct wpa_scan_results *scan_res, int pri_chan,
		   int sec_chan)
{
	int pri_freq, sec_freq, pri_bss, sec_bss;
	int bss_pri_chan, bss_sec_chan;
	size_t i;
	int match;

	if (!mode || !scan_res || !pri_chan || !sec_chan ||
	    pri_chan == sec_chan)
		return 0;

	pri_freq = hw_get_freq(mode, pri_chan);
	sec_freq = hw_get_freq(mode, sec_chan);

	/*
	 * Switch PRI/SEC channels if Beacons were detected on selected SEC
	 * channel, but not on selected PRI channel.
	 */
	pri_bss = sec_bss = 0;
	for (i = 0; i < scan_res->num; i++) {
		struct wpa_scan_res *bss = scan_res->res[i];
		if (bss->freq == pri_freq)
			pri_bss++;
		else if (bss->freq == sec_freq)
			sec_bss++;
	}
	if (sec_bss && !pri_bss) {
		wpa_printf(MSG_INFO,
			   "Switch own primary and secondary channel to get secondary channel with no Beacons from other BSSes");
		return 2;
	}

	/*
	 * Match PRI/SEC channel with any existing HT40 BSS on the same
	 * channels that we are about to use (if already mixed order in
	 * existing BSSes, use own preference).
	 */
	match = 0;
	for (i = 0; i < scan_res->num; i++) {
		struct wpa_scan_res *bss = scan_res->res[i];
		get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan);
		if (pri_chan == bss_pri_chan &&
		    sec_chan == bss_sec_chan) {
			match = 1;
			break;
		}
	}
	if (!match) {
		for (i = 0; i < scan_res->num; i++) {
			struct wpa_scan_res *bss = scan_res->res[i];
			get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan);
			if (pri_chan == bss_sec_chan &&
			    sec_chan == bss_pri_chan) {
				wpa_printf(MSG_INFO, "Switch own primary and "
					   "secondary channel due to BSS "
					   "overlap with " MACSTR,
					   MAC2STR(bss->bssid));
				return 2;
			}
		}
	}

	return 1;
}


static int check_20mhz_bss(struct wpa_scan_res *bss, int pri_freq, int start,
			   int end)
{
	struct ieee802_11_elems elems;
	struct ieee80211_ht_operation *oper;

	if (bss->freq < start || bss->freq > end || bss->freq == pri_freq)
		return 0;

	ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0);
	if (!elems.ht_capabilities) {
		wpa_printf(MSG_DEBUG, "Found overlapping legacy BSS: "
			   MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq);
		return 1;
	}

	if (elems.ht_operation) {
		oper = (struct ieee80211_ht_operation *) elems.ht_operation;
		if (oper->ht_param & HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK)
			return 0;

		wpa_printf(MSG_DEBUG, "Found overlapping 20 MHz HT BSS: "
			   MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq);
		return 1;
	}
	return 0;
}


int check_40mhz_2g4(struct hostapd_hw_modes *mode,
		    struct wpa_scan_results *scan_res, int pri_chan,
		    int sec_chan)
{
	int pri_freq, sec_freq;
	int affected_start, affected_end;
	size_t i;

	if (!mode || !scan_res || !pri_chan || !sec_chan ||
	    pri_chan == sec_chan)
		return 0;

	pri_freq = hw_get_freq(mode, pri_chan);
	sec_freq = hw_get_freq(mode, sec_chan);

	affected_start = (pri_freq + sec_freq) / 2 - 25;
	affected_end = (pri_freq + sec_freq) / 2 + 25;
	wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz",
		   affected_start, affected_end);
	for (i = 0; i < scan_res->num; i++) {
		struct wpa_scan_res *bss = scan_res->res[i];
		int pri = bss->freq;
		int sec = pri;
		struct ieee802_11_elems elems;

		/* Check for overlapping 20 MHz BSS */
		if (check_20mhz_bss(bss, pri_freq, affected_start,
				    affected_end)) {
			wpa_printf(MSG_DEBUG,
				   "Overlapping 20 MHz BSS is found");
			return 0;
		}

		get_pri_sec_chan(bss, &pri_chan, &sec_chan);

		if (sec_chan) {
			if (sec_chan < pri_chan)
				sec = pri - 20;
			else
				sec = pri + 20;
		}

		if ((pri < affected_start || pri > affected_end) &&
		    (sec < affected_start || sec > affected_end))
			continue; /* not within affected channel range */

		wpa_printf(MSG_DEBUG, "Neighboring BSS: " MACSTR
			   " freq=%d pri=%d sec=%d",
			   MAC2STR(bss->bssid), bss->freq, pri_chan, sec_chan);

		if (sec_chan) {
			if (pri_freq != pri || sec_freq != sec) {
				wpa_printf(MSG_DEBUG,
					   "40 MHz pri/sec mismatch with BSS "
					   MACSTR
					   " <%d,%d> (chan=%d%c) vs. <%d,%d>",
					   MAC2STR(bss->bssid),
					   pri, sec, pri_chan,
					   sec > pri ? '+' : '-',
					   pri_freq, sec_freq);
				return 0;
			}
		}

		ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems,
				       0);
		if (elems.ht_capabilities) {
			struct ieee80211_ht_capabilities *ht_cap =
				(struct ieee80211_ht_capabilities *)
				elems.ht_capabilities;

			if (le_to_host16(ht_cap->ht_capabilities_info) &
			    HT_CAP_INFO_40MHZ_INTOLERANT) {
				wpa_printf(MSG_DEBUG,
					   "40 MHz Intolerant is set on channel %d in BSS "
					   MACSTR, pri, MAC2STR(bss->bssid));
				return 0;
			}
		}
	}

	return 1;
}


int hostapd_set_freq_params(struct hostapd_freq_params *data,
			    enum hostapd_hw_mode mode,
			    int freq, int channel, int ht_enabled,
			    int vht_enabled, int he_enabled,
			    int sec_channel_offset,
			    int oper_chwidth, int center_segment0,
			    int center_segment1, u32 vht_caps,
			    struct he_capabilities *he_cap)
{
	if (!he_cap)
		he_enabled = 0;
	os_memset(data, 0, sizeof(*data));
	data->mode = mode;
	data->freq = freq;
	data->channel = channel;
	data->ht_enabled = ht_enabled;
	data->vht_enabled = vht_enabled;
	data->he_enabled = he_enabled;
	data->sec_channel_offset = sec_channel_offset;
	data->center_freq1 = freq + sec_channel_offset * 10;
	data->center_freq2 = 0;
	data->bandwidth = sec_channel_offset ? 40 : 20;

	if (data->vht_enabled) switch (oper_chwidth) {
	case CHANWIDTH_USE_HT:
		if (center_segment1 ||
		    (center_segment0 != 0 &&
		     5000 + center_segment0 * 5 != data->center_freq1 &&
		     2407 + center_segment0 * 5 != data->center_freq1))
			return -1;
		break;
	case CHANWIDTH_80P80MHZ:
		if (!(vht_caps & VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) {
			wpa_printf(MSG_ERROR,
				   "80+80 channel width is not supported!");
			return -1;
		}
		if (center_segment1 == center_segment0 + 4 ||
		    center_segment1 == center_segment0 - 4)
			return -1;
		data->center_freq2 = 5000 + center_segment1 * 5;
		/* fall through */
	case CHANWIDTH_80MHZ:
		data->bandwidth = 80;
		if ((oper_chwidth == CHANWIDTH_80MHZ &&
		     center_segment1) ||
		    (oper_chwidth == CHANWIDTH_80P80MHZ &&
		     !center_segment1) ||
		    !sec_channel_offset)
			return -1;
		if (!center_segment0) {
			if (channel <= 48)
				center_segment0 = 42;
			else if (channel <= 64)
				center_segment0 = 58;
			else if (channel <= 112)
				center_segment0 = 106;
			else if (channel <= 128)
				center_segment0 = 122;
			else if (channel <= 144)
				center_segment0 = 138;
			else if (channel <= 161)
				center_segment0 = 155;
			data->center_freq1 = 5000 + center_segment0 * 5;
		} else {
			/*
			 * Note: HT/VHT config and params are coupled. Check if
			 * HT40 channel band is in VHT80 Pri channel band
			 * configuration.
			 */
			if (center_segment0 == channel + 6 ||
			    center_segment0 == channel + 2 ||
			    center_segment0 == channel - 2 ||
			    center_segment0 == channel - 6)
				data->center_freq1 = 5000 + center_segment0 * 5;
			else
				return -1;
		}
		break;
	case CHANWIDTH_160MHZ:
		data->bandwidth = 160;
		if (!(vht_caps & (VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
				  VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))) {
			wpa_printf(MSG_ERROR,
				   "160MHZ channel width is not supported!");
			return -1;
		}
		if (center_segment1)
			return -1;
		if (!sec_channel_offset)
			return -1;
		/*
		 * Note: HT/VHT config and params are coupled. Check if
		 * HT40 channel band is in VHT160 channel band configuration.
		 */
		if (center_segment0 == channel + 14 ||
		    center_segment0 == channel + 10 ||
		    center_segment0 == channel + 6 ||
		    center_segment0 == channel + 2 ||
		    center_segment0 == channel - 2 ||
		    center_segment0 == channel - 6 ||
		    center_segment0 == channel - 10 ||
		    center_segment0 == channel - 14)
			data->center_freq1 = 5000 + center_segment0 * 5;
		else
			return -1;
		break;
	}

	return 0;
}


void set_disable_ht40(struct ieee80211_ht_capabilities *htcaps,
		      int disabled)
{
	/* Masking these out disables HT40 */
	le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
				HT_CAP_INFO_SHORT_GI40MHZ);

	if (disabled)
		htcaps->ht_capabilities_info &= ~msk;
	else
		htcaps->ht_capabilities_info |= msk;
}


#ifdef CONFIG_IEEE80211AC

static int _ieee80211ac_cap_check(u32 hw, u32 conf, u32 cap,
				  const char *name)
{
	u32 req_cap = conf & cap;

	/*
	 * Make sure we support all requested capabilities.
	 * NOTE: We assume that 'cap' represents a capability mask,
	 * not a discrete value.
	 */
	if ((hw & req_cap) != req_cap) {
		wpa_printf(MSG_ERROR,
			   "Driver does not support configured VHT capability [%s]",
			   name);
		return 0;
	}
	return 1;
}


static int ieee80211ac_cap_check_max(u32 hw, u32 conf, u32 mask,
				     unsigned int shift,
				     const char *name)
{
	u32 hw_max = hw & mask;
	u32 conf_val = conf & mask;

	if (conf_val > hw_max) {
		wpa_printf(MSG_ERROR,
			   "Configured VHT capability [%s] exceeds max value supported by the driver (%d > %d)",
			   name, conf_val >> shift, hw_max >> shift);
		return 0;
	}
	return 1;
}


int ieee80211ac_cap_check(u32 hw, u32 conf)
{
#define VHT_CAP_CHECK(cap) \
	do { \
		if (!_ieee80211ac_cap_check(hw, conf, cap, #cap)) \
			return 0; \
	} while (0)

#define VHT_CAP_CHECK_MAX(cap) \
	do { \
		if (!ieee80211ac_cap_check_max(hw, conf, cap, cap ## _SHIFT, \
					       #cap)) \
			return 0; \
	} while (0)

	VHT_CAP_CHECK_MAX(VHT_CAP_MAX_MPDU_LENGTH_MASK);
	VHT_CAP_CHECK_MAX(VHT_CAP_SUPP_CHAN_WIDTH_MASK);
	VHT_CAP_CHECK(VHT_CAP_RXLDPC);
	VHT_CAP_CHECK(VHT_CAP_SHORT_GI_80);
	VHT_CAP_CHECK(VHT_CAP_SHORT_GI_160);
	VHT_CAP_CHECK(VHT_CAP_TXSTBC);
	VHT_CAP_CHECK_MAX(VHT_CAP_RXSTBC_MASK);
	VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMER_CAPABLE);
	VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMEE_CAPABLE);
	VHT_CAP_CHECK_MAX(VHT_CAP_BEAMFORMEE_STS_MAX);
	VHT_CAP_CHECK_MAX(VHT_CAP_SOUNDING_DIMENSION_MAX);
	VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMER_CAPABLE);
	VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMEE_CAPABLE);
	VHT_CAP_CHECK(VHT_CAP_VHT_TXOP_PS);
	VHT_CAP_CHECK(VHT_CAP_HTC_VHT);
	VHT_CAP_CHECK_MAX(VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX);
	VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB);
	VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB);
	VHT_CAP_CHECK(VHT_CAP_RX_ANTENNA_PATTERN);
	VHT_CAP_CHECK(VHT_CAP_TX_ANTENNA_PATTERN);

#undef VHT_CAP_CHECK
#undef VHT_CAP_CHECK_MAX

	return 1;
}

#endif /* CONFIG_IEEE80211AC */


u32 num_chan_to_bw(int num_chans)
{
	switch (num_chans) {
	case 2:
	case 4:
	case 8:
		return num_chans * 20;
	default:
		return 20;
	}
}


/* check if BW is applicable for channel */
int chan_bw_allowed(const struct hostapd_channel_data *chan, u32 bw,
		    int ht40_plus, int pri)
{
	u32 bw_mask;

	switch (bw) {
	case 20:
		bw_mask = HOSTAPD_CHAN_WIDTH_20;
		break;
	case 40:
		/* HT 40 MHz support declared only for primary channel,
		 * just skip 40 MHz secondary checking */
		if (pri && ht40_plus)
			bw_mask = HOSTAPD_CHAN_WIDTH_40P;
		else if (pri && !ht40_plus)
			bw_mask = HOSTAPD_CHAN_WIDTH_40M;
		else
			bw_mask = 0;
		break;
	case 80:
		bw_mask = HOSTAPD_CHAN_WIDTH_80;
		break;
	case 160:
		bw_mask = HOSTAPD_CHAN_WIDTH_160;
		break;
	default:
		bw_mask = 0;
		break;
	}

	return (chan->allowed_bw & bw_mask) == bw_mask;
}


/* check if channel is allowed to be used as primary */
int chan_pri_allowed(const struct hostapd_channel_data *chan)
{
	return !(chan->flag & HOSTAPD_CHAN_DISABLED) &&
		(chan->allowed_bw & HOSTAPD_CHAN_WIDTH_20);
}
Commit	Line	Data
269dfe23 JD	1	/*
	2	* Common hostapd/wpa_supplicant HW features
	3	* Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi>
	4	* Copyright (c) 2015, 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 "includes.h"
	11
	12	#include "common.h"
	13	#include "defs.h"
6d5d098f JD	14	#include "ieee802_11_defs.h"
6d5d098f JD	15	#include "ieee802_11_common.h"
269dfe23 JD	16	#include "hw_features_common.h"
	17
	18
	19	struct hostapd_channel_data * hw_get_channel_chan(struct hostapd_hw_modes *mode,
	20	int chan, int *freq)
	21	{
	22	int i;
	23
	24	if (freq)
	25	*freq = 0;
	26
	27	if (!mode)
	28	return NULL;
	29
	30	for (i = 0; i < mode->num_channels; i++) {
	31	struct hostapd_channel_data *ch = &mode->channels[i];
	32	if (ch->chan == chan) {
	33	if (freq)
	34	*freq = ch->freq;
	35	return ch;
	36	}
	37	}
	38
	39	return NULL;
	40	}
	41
	42
	43	struct hostapd_channel_data * hw_get_channel_freq(struct hostapd_hw_modes *mode,
	44	int freq, int *chan)
	45	{
	46	int i;
	47
	48	if (chan)
	49	*chan = 0;
	50
	51	if (!mode)
	52	return NULL;
	53
	54	for (i = 0; i < mode->num_channels; i++) {
	55	struct hostapd_channel_data *ch = &mode->channels[i];
	56	if (ch->freq == freq) {
	57	if (chan)
	58	*chan = ch->chan;
	59	return ch;
	60	}
	61	}
	62
	63	return NULL;
	64	}
	65
	66
	67	int hw_get_freq(struct hostapd_hw_modes *mode, int chan)
	68	{
	69	int freq;
	70
	71	hw_get_channel_chan(mode, chan, &freq);
	72
	73	return freq;
	74	}
	75
	76
	77	int hw_get_chan(struct hostapd_hw_modes *mode, int freq)
	78	{
	79	int chan;
80
81	hw_get_channel_freq(mode, freq, &chan);
82
83	return chan;
84	}
51442743 JD	85
	86
	87	int allowed_ht40_channel_pair(struct hostapd_hw_modes *mode, int pri_chan,
	88	int sec_chan)
	89	{
ce6d9ce1	90	int ok, first;
6128a909	91	int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 140,
4ab0f11b	92	149, 157, 165, 184, 192 };
51442743	93	size_t k;
ce6d9ce1 DL	94	struct hostapd_channel_data p_chan, s_chan;
ce6d9ce1 DL	95	const int ht40_plus = pri_chan < sec_chan;
51442743	96
ce6d9ce1 DL	97	p_chan = hw_get_channel_chan(mode, pri_chan, NULL);
	98	if (!p_chan)
	99	return 0;
	100
	101	if (pri_chan == sec_chan \|\| !sec_chan) {
	102	if (chan_pri_allowed(p_chan))
	103	return 1; /* HT40 not used */
	104
	105	wpa_printf(MSG_ERROR, "Channel %d is not allowed as primary",
	106	pri_chan);
	107	return 0;
	108	}
	109
	110	s_chan = hw_get_channel_chan(mode, sec_chan, NULL);
	111	if (!s_chan)
	112	return 0;
51442743 JD	113
	114	wpa_printf(MSG_DEBUG,
	115	"HT40: control channel: %d secondary channel: %d",
	116	pri_chan, sec_chan);
	117
	118	/* Verify that HT40 secondary channel is an allowed 20 MHz
	119	* channel */
ce6d9ce1 DL	120	if ((s_chan->flag & HOSTAPD_CHAN_DISABLED) \|\|
	121	(ht40_plus && !(p_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40P)) \|\|
	122	(!ht40_plus && !(p_chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40M))) {
51442743 JD	123	wpa_printf(MSG_ERROR, "HT40 secondary channel %d not allowed",
	124	sec_chan);
	125	return 0;
	126	}
	127
	128	/*
	129	* Verify that HT40 primary,secondary channel pair is allowed per
	130	* IEEE 802.11n Annex J. This is only needed for 5 GHz band since
	131	* 2.4 GHz rules allow all cases where the secondary channel fits into
	132	* the list of allowed channels (already checked above).
	133	*/
	134	if (mode->mode != HOSTAPD_MODE_IEEE80211A)
	135	return 1;
	136
	137	first = pri_chan < sec_chan ? pri_chan : sec_chan;
	138
	139	ok = 0;
	140	for (k = 0; k < ARRAY_SIZE(allowed); k++) {
	141	if (first == allowed[k]) {
	142	ok = 1;
	143	break;
	144	}
	145	}
	146	if (!ok) {
	147	wpa_printf(MSG_ERROR, "HT40 channel pair (%d, %d) not allowed",
	148	pri_chan, sec_chan);
	149	return 0;
	150	}
	151
	152	return 1;
	153	}
6d5d098f JD	154
	155
	156	void get_pri_sec_chan(struct wpa_scan_res bss, int pri_chan, int *sec_chan)
	157	{
	158	struct ieee80211_ht_operation *oper;
	159	struct ieee802_11_elems elems;
	160
	161	pri_chan = sec_chan = 0;
	162
	163	ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0);
d6fefd64	164	if (elems.ht_operation) {
6d5d098f JD	165	oper = (struct ieee80211_ht_operation *) elems.ht_operation;
	166	*pri_chan = oper->primary_chan;
	167	if (oper->ht_param & HT_INFO_HT_PARAM_STA_CHNL_WIDTH) {
	168	int sec = oper->ht_param &
	169	HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK;
	170	if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_ABOVE)
	171	sec_chan = pri_chan + 4;
	172	else if (sec == HT_INFO_HT_PARAM_SECONDARY_CHNL_BELOW)
	173	sec_chan = pri_chan - 4;
	174	}
	175	}
	176	}
0e550fe4 JD	177
	178
	179	int check_40mhz_5g(struct hostapd_hw_modes *mode,
	180	struct wpa_scan_results *scan_res, int pri_chan,
	181	int sec_chan)
	182	{
	183	int pri_freq, sec_freq, pri_bss, sec_bss;
	184	int bss_pri_chan, bss_sec_chan;
	185	size_t i;
	186	int match;
	187
5ed65196 JM	188	if (!mode \|\| !scan_res \|\| !pri_chan \|\| !sec_chan \|\|
5ed65196 JM	189	pri_chan == sec_chan)
0e550fe4 JD	190	return 0;
	191
	192	pri_freq = hw_get_freq(mode, pri_chan);
	193	sec_freq = hw_get_freq(mode, sec_chan);
	194
	195	/*
	196	* Switch PRI/SEC channels if Beacons were detected on selected SEC
	197	* channel, but not on selected PRI channel.
	198	*/
	199	pri_bss = sec_bss = 0;
	200	for (i = 0; i < scan_res->num; i++) {
	201	struct wpa_scan_res *bss = scan_res->res[i];
	202	if (bss->freq == pri_freq)
	203	pri_bss++;
	204	else if (bss->freq == sec_freq)
	205	sec_bss++;
	206	}
	207	if (sec_bss && !pri_bss) {
	208	wpa_printf(MSG_INFO,
	209	"Switch own primary and secondary channel to get secondary channel with no Beacons from other BSSes");
	210	return 2;
	211	}
	212
	213	/*
	214	* Match PRI/SEC channel with any existing HT40 BSS on the same
	215	* channels that we are about to use (if already mixed order in
	216	* existing BSSes, use own preference).
	217	*/
	218	match = 0;
	219	for (i = 0; i < scan_res->num; i++) {
	220	struct wpa_scan_res *bss = scan_res->res[i];
	221	get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan);
	222	if (pri_chan == bss_pri_chan &&
	223	sec_chan == bss_sec_chan) {
	224	match = 1;
	225	break;
	226	}
	227	}
	228	if (!match) {
	229	for (i = 0; i < scan_res->num; i++) {
	230	struct wpa_scan_res *bss = scan_res->res[i];
	231	get_pri_sec_chan(bss, &bss_pri_chan, &bss_sec_chan);
	232	if (pri_chan == bss_sec_chan &&
	233	sec_chan == bss_pri_chan) {
	234	wpa_printf(MSG_INFO, "Switch own primary and "
	235	"secondary channel due to BSS "
	236	"overlap with " MACSTR,
	237	MAC2STR(bss->bssid));
	238	return 2;
	239	}
	240	}
	241	}
	242
	243	return 1;
	244	}
fdd989d1 JD	245
fdd989d1 JD	246
1887be4f JM	247	static int check_20mhz_bss(struct wpa_scan_res *bss, int pri_freq, int start,
1887be4f JM	248	int end)
fdd989d1 JD	249	{
	250	struct ieee802_11_elems elems;
	251	struct ieee80211_ht_operation *oper;
	252
	253	if (bss->freq < start \|\| bss->freq > end \|\| bss->freq == pri_freq)
	254	return 0;
	255
	256	ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0);
	257	if (!elems.ht_capabilities) {
	258	wpa_printf(MSG_DEBUG, "Found overlapping legacy BSS: "
	259	MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq);
	260	return 1;
	261	}
	262
d6fefd64	263	if (elems.ht_operation) {
fdd989d1 JD	264	oper = (struct ieee80211_ht_operation *) elems.ht_operation;
	265	if (oper->ht_param & HT_INFO_HT_PARAM_SECONDARY_CHNL_OFF_MASK)
	266	return 0;
	267
	268	wpa_printf(MSG_DEBUG, "Found overlapping 20 MHz HT BSS: "
	269	MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq);
	270	return 1;
	271	}
	272	return 0;
	273	}
a828f626 JD	274
	275
	276	int check_40mhz_2g4(struct hostapd_hw_modes *mode,
	277	struct wpa_scan_results *scan_res, int pri_chan,
	278	int sec_chan)
	279	{
	280	int pri_freq, sec_freq;
	281	int affected_start, affected_end;
	282	size_t i;
	283
35963617 JM	284	if (!mode \|\| !scan_res \|\| !pri_chan \|\| !sec_chan \|\|
35963617 JM	285	pri_chan == sec_chan)
a828f626 JD	286	return 0;
	287
	288	pri_freq = hw_get_freq(mode, pri_chan);
	289	sec_freq = hw_get_freq(mode, sec_chan);
	290
	291	affected_start = (pri_freq + sec_freq) / 2 - 25;
	292	affected_end = (pri_freq + sec_freq) / 2 + 25;
	293	wpa_printf(MSG_DEBUG, "40 MHz affected channel range: [%d,%d] MHz",
	294	affected_start, affected_end);
	295	for (i = 0; i < scan_res->num; i++) {
	296	struct wpa_scan_res *bss = scan_res->res[i];
	297	int pri = bss->freq;
	298	int sec = pri;
	299	struct ieee802_11_elems elems;
	300
	301	/* Check for overlapping 20 MHz BSS */
	302	if (check_20mhz_bss(bss, pri_freq, affected_start,
	303	affected_end)) {
	304	wpa_printf(MSG_DEBUG,
	305	"Overlapping 20 MHz BSS is found");
	306	return 0;
	307	}
	308
	309	get_pri_sec_chan(bss, &pri_chan, &sec_chan);
	310
	311	if (sec_chan) {
	312	if (sec_chan < pri_chan)
	313	sec = pri - 20;
	314	else
	315	sec = pri + 20;
	316	}
	317
	318	if ((pri < affected_start \|\| pri > affected_end) &&
	319	(sec < affected_start \|\| sec > affected_end))
	320	continue; /* not within affected channel range */
	321
	322	wpa_printf(MSG_DEBUG, "Neighboring BSS: " MACSTR
	323	" freq=%d pri=%d sec=%d",
	324	MAC2STR(bss->bssid), bss->freq, pri_chan, sec_chan);
	325
	326	if (sec_chan) {
	327	if (pri_freq != pri \|\| sec_freq != sec) {
	328	wpa_printf(MSG_DEBUG,
	329	"40 MHz pri/sec mismatch with BSS "
	330	MACSTR
	331	" <%d,%d> (chan=%d%c) vs. <%d,%d>",
	332	MAC2STR(bss->bssid),
	333	pri, sec, pri_chan,
	334	sec > pri ? '+' : '-',
	335	pri_freq, sec_freq);
	336	return 0;
	337	}
	338	}
	339
	340	ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems,
	341	0);
baae4cb9	342	if (elems.ht_capabilities) {
a828f626 JD	343	struct ieee80211_ht_capabilities *ht_cap =
	344	(struct ieee80211_ht_capabilities *)
	345	elems.ht_capabilities;
	346
	347	if (le_to_host16(ht_cap->ht_capabilities_info) &
	348	HT_CAP_INFO_40MHZ_INTOLERANT) {
	349	wpa_printf(MSG_DEBUG,
	350	"40 MHz Intolerant is set on channel %d in BSS "
	351	MACSTR, pri, MAC2STR(bss->bssid));
	352	return 0;
	353	}
	354	}
	355	}
	356
	357	return 1;
	358	}
ada157f3 JD	359
	360
	361	int hostapd_set_freq_params(struct hostapd_freq_params *data,
	362	enum hostapd_hw_mode mode,
	363	int freq, int channel, int ht_enabled,
88005ee9 JC	364	int vht_enabled, int he_enabled,
88005ee9 JC	365	int sec_channel_offset,
b04e4308	366	int oper_chwidth, int center_segment0,
88005ee9 JC	367	int center_segment1, u32 vht_caps,
88005ee9 JC	368	struct he_capabilities *he_cap)
ada157f3	369	{
88005ee9 JC	370	if (!he_cap)
88005ee9 JC	371	he_enabled = 0;
ada157f3 JD	372	os_memset(data, 0, sizeof(*data));
	373	data->mode = mode;
	374	data->freq = freq;
	375	data->channel = channel;
	376	data->ht_enabled = ht_enabled;
	377	data->vht_enabled = vht_enabled;
88005ee9	378	data->he_enabled = he_enabled;
ada157f3 JD	379	data->sec_channel_offset = sec_channel_offset;
	380	data->center_freq1 = freq + sec_channel_offset * 10;
	381	data->center_freq2 = 0;
	382	data->bandwidth = sec_channel_offset ? 40 : 20;
	383
b04e4308	384	if (data->vht_enabled) switch (oper_chwidth) {
464dcfd0	385	case CHANWIDTH_USE_HT:
5ed65196 JM	386	if (center_segment1 \|\|
	387	(center_segment0 != 0 &&
	388	5000 + center_segment0 * 5 != data->center_freq1 &&
	389	2407 + center_segment0 * 5 != data->center_freq1))
ada157f3 JD	390	return -1;
ada157f3 JD	391	break;
464dcfd0	392	case CHANWIDTH_80P80MHZ:
ada157f3 JD	393	if (!(vht_caps & VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) {
	394	wpa_printf(MSG_ERROR,
	395	"80+80 channel width is not supported!");
	396	return -1;
	397	}
	398	if (center_segment1 == center_segment0 + 4 \|\|
	399	center_segment1 == center_segment0 - 4)
	400	return -1;
	401	data->center_freq2 = 5000 + center_segment1 * 5;
	402	/* fall through */
464dcfd0	403	case CHANWIDTH_80MHZ:
ada157f3	404	data->bandwidth = 80;
b04e4308	405	if ((oper_chwidth == CHANWIDTH_80MHZ &&
4d6e79f8	406	center_segment1) \|\|
b04e4308	407	(oper_chwidth == CHANWIDTH_80P80MHZ &&
4d6e79f8	408	!center_segment1) \|\|
5ed65196	409	!sec_channel_offset)
ada157f3	410	return -1;
857d9422 MM	411	if (!center_segment0) {
	412	if (channel <= 48)
	413	center_segment0 = 42;
	414	else if (channel <= 64)
	415	center_segment0 = 58;
	416	else if (channel <= 112)
	417	center_segment0 = 106;
	418	else if (channel <= 128)
	419	center_segment0 = 122;
	420	else if (channel <= 144)
	421	center_segment0 = 138;
	422	else if (channel <= 161)
	423	center_segment0 = 155;
	424	data->center_freq1 = 5000 + center_segment0 * 5;
	425	} else {
	426	/*
	427	* Note: HT/VHT config and params are coupled. Check if
	428	* HT40 channel band is in VHT80 Pri channel band
	429	* configuration.
	430	*/
	431	if (center_segment0 == channel + 6 \|\|
	432	center_segment0 == channel + 2 \|\|
	433	center_segment0 == channel - 2 \|\|
	434	center_segment0 == channel - 6)
	435	data->center_freq1 = 5000 + center_segment0 * 5;
	436	else
	437	return -1;
	438	}
ada157f3	439	break;
464dcfd0	440	case CHANWIDTH_160MHZ:
ada157f3 JD	441	data->bandwidth = 160;
	442	if (!(vht_caps & (VHT_CAP_SUPP_CHAN_WIDTH_160MHZ \|
	443	VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))) {
	444	wpa_printf(MSG_ERROR,
	445	"160MHZ channel width is not supported!");
	446	return -1;
	447	}
	448	if (center_segment1)
	449	return -1;
	450	if (!sec_channel_offset)
	451	return -1;
857d9422 MM	452	/*
	453	* Note: HT/VHT config and params are coupled. Check if
	454	* HT40 channel band is in VHT160 channel band configuration.
	455	*/
	456	if (center_segment0 == channel + 14 \|\|
	457	center_segment0 == channel + 10 \|\|
	458	center_segment0 == channel + 6 \|\|
	459	center_segment0 == channel + 2 \|\|
	460	center_segment0 == channel - 2 \|\|
	461	center_segment0 == channel - 6 \|\|
	462	center_segment0 == channel - 10 \|\|
	463	center_segment0 == channel - 14)
	464	data->center_freq1 = 5000 + center_segment0 * 5;
	465	else
ada157f3	466	return -1;
ada157f3 JD	467	break;
	468	}
	469
	470	return 0;
	471	}
9eb5757a MH	472
	473
	474	void set_disable_ht40(struct ieee80211_ht_capabilities *htcaps,
	475	int disabled)
	476	{
	477	/* Masking these out disables HT40 */
	478	le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET \|
	479	HT_CAP_INFO_SHORT_GI40MHZ);
	480
	481	if (disabled)
	482	htcaps->ht_capabilities_info &= ~msk;
	483	else
	484	htcaps->ht_capabilities_info \|= msk;
	485	}
a7a638c2 MH	486
	487
	488	#ifdef CONFIG_IEEE80211AC
	489
	490	static int _ieee80211ac_cap_check(u32 hw, u32 conf, u32 cap,
	491	const char *name)
	492	{
	493	u32 req_cap = conf & cap;
	494
	495	/*
	496	* Make sure we support all requested capabilities.
	497	* NOTE: We assume that 'cap' represents a capability mask,
	498	* not a discrete value.
	499	*/
	500	if ((hw & req_cap) != req_cap) {
	501	wpa_printf(MSG_ERROR,
	502	"Driver does not support configured VHT capability [%s]",
	503	name);
	504	return 0;
	505	}
	506	return 1;
	507	}
	508
	509
	510	static int ieee80211ac_cap_check_max(u32 hw, u32 conf, u32 mask,
	511	unsigned int shift,
	512	const char *name)
	513	{
	514	u32 hw_max = hw & mask;
	515	u32 conf_val = conf & mask;
	516
	517	if (conf_val > hw_max) {
	518	wpa_printf(MSG_ERROR,
	519	"Configured VHT capability [%s] exceeds max value supported by the driver (%d > %d)",
	520	name, conf_val >> shift, hw_max >> shift);
	521	return 0;
	522	}
	523	return 1;
	524	}
	525
	526
	527	int ieee80211ac_cap_check(u32 hw, u32 conf)
	528	{
	529	#define VHT_CAP_CHECK(cap) \
	530	do { \
	531	if (!_ieee80211ac_cap_check(hw, conf, cap, #cap)) \
	532	return 0; \
	533	} while (0)
	534
	535	#define VHT_CAP_CHECK_MAX(cap) \
	536	do { \
	537	if (!ieee80211ac_cap_check_max(hw, conf, cap, cap ## _SHIFT, \
	538	#cap)) \
	539	return 0; \
	540	} while (0)
	541
	542	VHT_CAP_CHECK_MAX(VHT_CAP_MAX_MPDU_LENGTH_MASK);
b0fc2ef3	543	VHT_CAP_CHECK_MAX(VHT_CAP_SUPP_CHAN_WIDTH_MASK);
a7a638c2 MH	544	VHT_CAP_CHECK(VHT_CAP_RXLDPC);
	545	VHT_CAP_CHECK(VHT_CAP_SHORT_GI_80);
	546	VHT_CAP_CHECK(VHT_CAP_SHORT_GI_160);
	547	VHT_CAP_CHECK(VHT_CAP_TXSTBC);
	548	VHT_CAP_CHECK_MAX(VHT_CAP_RXSTBC_MASK);
	549	VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMER_CAPABLE);
	550	VHT_CAP_CHECK(VHT_CAP_SU_BEAMFORMEE_CAPABLE);
	551	VHT_CAP_CHECK_MAX(VHT_CAP_BEAMFORMEE_STS_MAX);
	552	VHT_CAP_CHECK_MAX(VHT_CAP_SOUNDING_DIMENSION_MAX);
	553	VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMER_CAPABLE);
	554	VHT_CAP_CHECK(VHT_CAP_MU_BEAMFORMEE_CAPABLE);
	555	VHT_CAP_CHECK(VHT_CAP_VHT_TXOP_PS);
	556	VHT_CAP_CHECK(VHT_CAP_HTC_VHT);
	557	VHT_CAP_CHECK_MAX(VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX);
	558	VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_UNSOL_MFB);
	559	VHT_CAP_CHECK(VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB);
	560	VHT_CAP_CHECK(VHT_CAP_RX_ANTENNA_PATTERN);
	561	VHT_CAP_CHECK(VHT_CAP_TX_ANTENNA_PATTERN);
	562
	563	#undef VHT_CAP_CHECK
	564	#undef VHT_CAP_CHECK_MAX
	565
	566	return 1;
	567	}
	568
	569	#endif /* CONFIG_IEEE80211AC */
ce6d9ce1 DL	570
	571
	572	u32 num_chan_to_bw(int num_chans)
	573	{
	574	switch (num_chans) {
	575	case 2:
	576	case 4:
	577	case 8:
	578	return num_chans * 20;
	579	default:
	580	return 20;
	581	}
	582	}
	583
	584
	585	/* check if BW is applicable for channel */
	586	int chan_bw_allowed(const struct hostapd_channel_data *chan, u32 bw,
	587	int ht40_plus, int pri)
	588	{
	589	u32 bw_mask;
	590
	591	switch (bw) {
	592	case 20:
	593	bw_mask = HOSTAPD_CHAN_WIDTH_20;
	594	break;
	595	case 40:
	596	/* HT 40 MHz support declared only for primary channel,
	597	* just skip 40 MHz secondary checking */
	598	if (pri && ht40_plus)
	599	bw_mask = HOSTAPD_CHAN_WIDTH_40P;
	600	else if (pri && !ht40_plus)
	601	bw_mask = HOSTAPD_CHAN_WIDTH_40M;
	602	else
	603	bw_mask = 0;
	604	break;
	605	case 80:
	606	bw_mask = HOSTAPD_CHAN_WIDTH_80;
	607	break;
	608	case 160:
	609	bw_mask = HOSTAPD_CHAN_WIDTH_160;
	610	break;
	611	default:
	612	bw_mask = 0;
	613	break;
	614	}
	615
	616	return (chan->allowed_bw & bw_mask) == bw_mask;
	617	}
	618
	619
	620	/* check if channel is allowed to be used as primary */
	621	int chan_pri_allowed(const struct hostapd_channel_data *chan)
	622	{
	623	return !(chan->flag & HOSTAPD_CHAN_DISABLED) &&
	624	(chan->allowed_bw & HOSTAPD_CHAN_WIDTH_20);
	625	}