/* * Common hostapd/wpa_supplicant HW features * Copyright (c) 2002-2013, Jouni Malinen * 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_mode_get_channel(struct hostapd_hw_modes *mode, int freq, int *chan) { int i; 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; } struct hostapd_channel_data * hw_get_channel_freq(enum hostapd_hw_mode mode, int freq, int *chan, struct hostapd_hw_modes *hw_features, int num_hw_features) { struct hostapd_channel_data *chan_data; int i; if (chan) *chan = 0; if (!hw_features) return NULL; for (i = 0; i < num_hw_features; i++) { struct hostapd_hw_modes *curr_mode = &hw_features[i]; if (curr_mode->mode != mode) continue; chan_data = hw_mode_get_channel(curr_mode, freq, chan); if (chan_data) return chan_data; } 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(enum hostapd_hw_mode mode, int freq, struct hostapd_hw_modes *hw_features, int num_hw_features) { int chan; hw_get_channel_freq(mode, freq, &chan, hw_features, num_hw_features); return chan; } int allowed_ht40_channel_pair(enum hostapd_hw_mode mode, struct hostapd_channel_data *p_chan, struct hostapd_channel_data *s_chan) { int ok, first; int allowed[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 140, 149, 157, 165, 173, 184, 192 }; size_t k; int ht40_plus, pri_chan, sec_chan; if (!p_chan || !s_chan) return 0; pri_chan = p_chan->chan; sec_chan = s_chan->chan; ht40_plus = pri_chan < sec_chan; 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; } wpa_printf(MSG_DEBUG, "HT40: control channel: %d (%d MHz), secondary channel: %d (%d MHz)", pri_chan, p_chan->freq, sec_chan, s_chan->freq); /* 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 != 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; if (ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0) != ParseFailed && 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 wpa_scan_results *scan_res, struct hostapd_channel_data *pri_chan, struct hostapd_channel_data *sec_chan) { int pri_bss, sec_bss; int bss_pri_chan, bss_sec_chan; size_t i; int match; if (!scan_res || !pri_chan || !sec_chan || pri_chan->freq == sec_chan->freq) return 0; /* * 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_chan->freq) pri_bss++; else if (bss->freq == sec_chan->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->chan == bss_pri_chan && sec_chan->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->chan == bss_sec_chan && sec_chan->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; if (ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0) == ParseFailed) return 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; } } if (ieee802_11_parse_elems((u8 *) (bss + 1), bss->ie_len, &elems, 0) != ParseFailed && 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 enable_edmg, u8 edmg_channel, int ht_enabled, int vht_enabled, int he_enabled, bool eht_enabled, int sec_channel_offset, enum oper_chan_width oper_chwidth, int center_segment0, int center_segment1, u32 vht_caps, struct he_capabilities *he_cap, struct eht_capabilities *eht_cap) { if (!he_cap || !he_cap->he_supported) he_enabled = 0; if (!eht_cap || !eht_cap->eht_supported) eht_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->eht_enabled = eht_enabled; data->sec_channel_offset = sec_channel_offset; data->center_freq1 = freq + sec_channel_offset * 10; data->center_freq2 = 0; if (oper_chwidth == CONF_OPER_CHWIDTH_80MHZ) data->bandwidth = 80; else if (oper_chwidth == CONF_OPER_CHWIDTH_160MHZ || oper_chwidth == CONF_OPER_CHWIDTH_80P80MHZ) data->bandwidth = 160; else if (oper_chwidth == CONF_OPER_CHWIDTH_320MHZ) data->bandwidth = 320; else if (sec_channel_offset) data->bandwidth = 40; else data->bandwidth = 20; hostapd_encode_edmg_chan(enable_edmg, edmg_channel, channel, &data->edmg); if (is_6ghz_freq(freq)) { if (!data->he_enabled && !data->eht_enabled) { wpa_printf(MSG_ERROR, "Can't set 6 GHz mode - HE or EHT aren't enabled"); return -1; } if (center_idx_to_bw_6ghz(channel) < 0) { wpa_printf(MSG_ERROR, "Invalid control channel for 6 GHz band"); return -1; } if (!center_segment0) { if (center_segment1) { wpa_printf(MSG_ERROR, "Segment 0 center frequency isn't set"); return -1; } if (!sec_channel_offset) data->center_freq1 = data->freq; } else { int freq1, freq2 = 0; int bw = center_idx_to_bw_6ghz(center_segment0); if (bw < 0) { wpa_printf(MSG_ERROR, "Invalid center frequency index for 6 GHz"); return -1; } freq1 = ieee80211_chan_to_freq(NULL, 131, center_segment0); if (freq1 < 0) { wpa_printf(MSG_ERROR, "Invalid segment 0 center frequency for 6 GHz"); return -1; } if (center_segment1) { if (center_idx_to_bw_6ghz(center_segment1) != 2 || bw != 2) { wpa_printf(MSG_ERROR, "6 GHz 80+80 MHz configuration doesn't use valid 80 MHz channels"); return -1; } freq2 = ieee80211_chan_to_freq(NULL, 131, center_segment1); if (freq2 < 0) { wpa_printf(MSG_ERROR, "Invalid segment 1 center frequency for UHB"); return -1; } } data->bandwidth = (1 << (u8) bw) * 20; data->center_freq1 = freq1; data->center_freq2 = freq2; } data->ht_enabled = 0; data->vht_enabled = 0; return 0; } if (data->eht_enabled) switch (oper_chwidth) { case CONF_OPER_CHWIDTH_320MHZ: if (!(eht_cap->phy_cap[EHT_PHYCAP_320MHZ_IN_6GHZ_SUPPORT_IDX] & EHT_PHYCAP_320MHZ_IN_6GHZ_SUPPORT_MASK)) { wpa_printf(MSG_ERROR, "320 MHz channel width is not supported in 5 or 6 GHz"); return -1; } break; default: break; } if (data->he_enabled || data->eht_enabled) switch (oper_chwidth) { case CONF_OPER_CHWIDTH_USE_HT: if (sec_channel_offset == 0) break; if (mode == HOSTAPD_MODE_IEEE80211G) { if (he_cap && !(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & HE_PHYCAP_CHANNEL_WIDTH_SET_40MHZ_IN_2G)) { wpa_printf(MSG_ERROR, "40 MHz channel width is not supported in 2.4 GHz"); return -1; } break; } /* fall through */ case CONF_OPER_CHWIDTH_80MHZ: if (mode == HOSTAPD_MODE_IEEE80211A) { if (he_cap && !(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & HE_PHYCAP_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G)) { wpa_printf(MSG_ERROR, "40/80 MHz channel width is not supported in 5/6 GHz"); return -1; } } break; case CONF_OPER_CHWIDTH_80P80MHZ: if (he_cap && !(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & HE_PHYCAP_CHANNEL_WIDTH_SET_80PLUS80MHZ_IN_5G)) { wpa_printf(MSG_ERROR, "80+80 MHz channel width is not supported in 5/6 GHz"); return -1; } break; case CONF_OPER_CHWIDTH_160MHZ: if (he_cap && !(he_cap->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & HE_PHYCAP_CHANNEL_WIDTH_SET_160MHZ_IN_5G)) { wpa_printf(MSG_ERROR, "160 MHz channel width is not supported in 5 / 6GHz"); return -1; } break; default: break; } else if (data->vht_enabled) switch (oper_chwidth) { case CONF_OPER_CHWIDTH_USE_HT: break; case CONF_OPER_CHWIDTH_80P80MHZ: if (!(vht_caps & VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) { wpa_printf(MSG_ERROR, "80+80 channel width is not supported!"); return -1; } /* fall through */ case CONF_OPER_CHWIDTH_80MHZ: break; case CONF_OPER_CHWIDTH_160MHZ: if (!(vht_caps & (VHT_CAP_SUPP_CHAN_WIDTH_160MHZ | VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))) { wpa_printf(MSG_ERROR, "160 MHz channel width is not supported!"); return -1; } break; default: break; } if (data->eht_enabled || data->he_enabled || data->vht_enabled) switch (oper_chwidth) { case CONF_OPER_CHWIDTH_USE_HT: if (center_segment1 || (center_segment0 != 0 && 5000 + center_segment0 * 5 != data->center_freq1 && 2407 + center_segment0 * 5 != data->center_freq1)) { wpa_printf(MSG_ERROR, "20/40 MHz: center segment 0 (=%d) and center freq 1 (=%d) not in sync", center_segment0, data->center_freq1); return -1; } break; case CONF_OPER_CHWIDTH_80P80MHZ: if (center_segment1 == center_segment0 + 4 || center_segment1 == center_segment0 - 4) { wpa_printf(MSG_ERROR, "80+80 MHz: center segment 1 only 20 MHz apart"); return -1; } data->center_freq2 = 5000 + center_segment1 * 5; /* fall through */ case CONF_OPER_CHWIDTH_80MHZ: data->bandwidth = 80; if (!sec_channel_offset) { wpa_printf(MSG_ERROR, "80/80+80 MHz: no second channel offset"); return -1; } if (oper_chwidth == CONF_OPER_CHWIDTH_80MHZ && center_segment1) { wpa_printf(MSG_ERROR, "80 MHz: center segment 1 configured"); return -1; } if (oper_chwidth == CONF_OPER_CHWIDTH_80P80MHZ && !center_segment1) { wpa_printf(MSG_ERROR, "80+80 MHz: center segment 1 not configured"); 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; else if (channel <= 177) center_segment0 = 171; 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 { wpa_printf(MSG_ERROR, "Wrong coupling between HT and VHT/HE channel setting"); return -1; } } break; case CONF_OPER_CHWIDTH_160MHZ: data->bandwidth = 160; if (center_segment1) { wpa_printf(MSG_ERROR, "160 MHz: center segment 1 should not be set"); return -1; } if (!sec_channel_offset) { wpa_printf(MSG_ERROR, "160 MHz: second channel offset not set"); 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 { wpa_printf(MSG_ERROR, "160 MHz: HT40 channel band is not in 160 MHz band"); return -1; } break; case CONF_OPER_CHWIDTH_320MHZ: data->bandwidth = 320; if (!data->eht_enabled || !is_6ghz_freq(freq)) { wpa_printf(MSG_ERROR, "320 MHz: EHT not enabled or not a 6 GHz channel"); return -1; } if (center_segment1) { wpa_printf(MSG_ERROR, "320 MHz: center segment 1 should not be set"); return -1; } if (center_segment0 == channel + 30 || center_segment0 == channel + 26 || center_segment0 == channel + 22 || center_segment0 == channel + 18 || 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 || center_segment0 == channel - 18 || center_segment0 == channel - 22 || center_segment0 == channel - 26 || center_segment0 == channel - 30) data->center_freq1 = 5000 + center_segment0 * 5; else { wpa_printf(MSG_ERROR, "320 MHz: wrong center segment 0"); return -1; } break; default: 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: case 16: 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; case 320: bw_mask = HOSTAPD_CHAN_WIDTH_320; 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); } /* IEEE P802.11be/D3.0, Table 36-30 - Definition of the Punctured Channel * Information field in the U-SIG for an EHT MU PPDU using non-OFDMA * transmissions */ static const u16 punct_bitmap_80[] = { 0xF, 0xE, 0xD, 0xB, 0x7 }; static const u16 punct_bitmap_160[] = { 0xFF, 0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xFC, 0xF3, 0xCF, 0x3F }; static const u16 punct_bitmap_320[] = { 0xFFFF, 0xFFFC, 0xFFF3, 0xFFCF, 0xFF3F, 0xFCFF, 0xF3FF, 0xCFFF, 0x3FFF, 0xFFF0, 0xFF0F, 0xF0FF, 0x0FFF, 0xFFC0, 0xFF30, 0xFCF0, 0xF3F0, 0xCFF0, 0x3FF0, 0x0FFC, 0x0FF3, 0x0FCF, 0x0F3F, 0x0CFF, 0x03FF }; bool is_punct_bitmap_valid(u16 bw, u16 pri_ch_bit_pos, u16 punct_bitmap) { u8 i, count; u16 bitmap; const u16 *valid_bitmaps; if (!punct_bitmap) /* All channels active */ return true; bitmap = ~punct_bitmap; switch (bw) { case 80: bitmap &= 0xF; valid_bitmaps = punct_bitmap_80; count = ARRAY_SIZE(punct_bitmap_80); break; case 160: bitmap &= 0xFF; valid_bitmaps = punct_bitmap_160; count = ARRAY_SIZE(punct_bitmap_160); break; case 320: bitmap &= 0xFFFF; valid_bitmaps = punct_bitmap_320; count = ARRAY_SIZE(punct_bitmap_320); break; default: return false; } if (!bitmap) /* No channel active */ return false; if (!(bitmap & BIT(pri_ch_bit_pos))) { wpa_printf(MSG_DEBUG, "Primary channel cannot be punctured"); return false; } for (i = 0; i < count; i++) { if (valid_bitmaps[i] == bitmap) return true; } return false; }