X-Git-Url: https://git.rohieb.name/openwrt.git/blobdiff_plain/1da648ca46b0a0cc82de8ef2bfe34b792b6fb687..4677737b0a940c4be5edc717c9ce5085e4101f24:/package/mac80211/patches/300-pending_work.patch diff --git a/package/mac80211/patches/300-pending_work.patch b/package/mac80211/patches/300-pending_work.patch index 40fd32db2..371e82bca 100644 --- a/package/mac80211/patches/300-pending_work.patch +++ b/package/mac80211/patches/300-pending_work.patch @@ -1,86 +1,729 @@ ---- a/drivers/net/wireless/ath/ath9k/main.c -+++ b/drivers/net/wireless/ath/ath9k/main.c -@@ -1048,6 +1048,8 @@ static int ath9k_start(struct ieee80211_ - "Starting driver with initial channel: %d MHz\n", - curchan->center_freq); +--- a/include/net/cfg80211.h ++++ b/include/net/cfg80211.h +@@ -1122,6 +1122,7 @@ struct cfg80211_ibss_params { + u8 *ssid; + u8 *bssid; + struct ieee80211_channel *channel; ++ enum nl80211_channel_type channel_type; + u8 *ie; + u8 ssid_len, ie_len; + u16 beacon_interval; +@@ -3188,6 +3189,16 @@ void cfg80211_gtk_rekey_notify(struct ne + void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index, + const u8 *bssid, bool preauth, gfp_t gfp); -+ ath9k_ps_wakeup(sc); ++/** ++ * cfg80211_can_use_ext_chan - test if ht40 on extension channel can be used ++ * @wiphy: the wiphy ++ * @chan: main channel ++ * @channel_type: HT mode ++ */ ++bool cfg80211_can_beacon_sec_chan(struct wiphy *wiphy, ++ struct ieee80211_channel *chan, ++ enum nl80211_channel_type channel_type); + - mutex_lock(&sc->mutex); + /* Logging, debugging and troubleshooting/diagnostic helpers. */ - /* setup initial channel */ -@@ -1143,6 +1145,8 @@ static int ath9k_start(struct ieee80211_ - mutex_unlock: - mutex_unlock(&sc->mutex); + /* wiphy_printk helpers, similar to dev_printk */ +--- a/net/mac80211/agg-rx.c ++++ b/net/mac80211/agg-rx.c +@@ -180,6 +180,10 @@ static void ieee80211_send_addba_resp(st + memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); + else if (sdata->vif.type == NL80211_IFTYPE_STATION) + memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); ++ else if (sdata->vif.type == NL80211_IFTYPE_WDS) ++ memcpy(mgmt->bssid, da, ETH_ALEN); ++ else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) ++ memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN); -+ ath9k_ps_restore(sc); -+ - return r; - } + mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | + IEEE80211_STYPE_ACTION); +--- a/net/mac80211/agg-tx.c ++++ b/net/mac80211/agg-tx.c +@@ -77,10 +77,13 @@ static void ieee80211_send_addba_request + memcpy(mgmt->da, da, ETH_ALEN); + memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); + if (sdata->vif.type == NL80211_IFTYPE_AP || +- sdata->vif.type == NL80211_IFTYPE_AP_VLAN) ++ sdata->vif.type == NL80211_IFTYPE_AP_VLAN || ++ sdata->vif.type == NL80211_IFTYPE_WDS) + memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); + else if (sdata->vif.type == NL80211_IFTYPE_STATION) + memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); ++ else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) ++ memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN); + + mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | + IEEE80211_STYPE_ACTION); +@@ -397,7 +400,9 @@ int ieee80211_start_tx_ba_session(struct + */ + if (sdata->vif.type != NL80211_IFTYPE_STATION && + sdata->vif.type != NL80211_IFTYPE_AP_VLAN && +- sdata->vif.type != NL80211_IFTYPE_AP) ++ sdata->vif.type != NL80211_IFTYPE_AP && ++ sdata->vif.type != NL80211_IFTYPE_ADHOC && ++ sdata->vif.type != NL80211_IFTYPE_WDS) + return -EINVAL; + if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) { +--- a/net/mac80211/debugfs_sta.c ++++ b/net/mac80211/debugfs_sta.c +@@ -63,11 +63,11 @@ static ssize_t sta_flags_read(struct fil + test_sta_flag(sta, WLAN_STA_##flg) ? #flg "\n" : "" + + int res = scnprintf(buf, sizeof(buf), +- "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", ++ "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", + TEST(AUTH), TEST(ASSOC), TEST(PS_STA), + TEST(PS_DRIVER), TEST(AUTHORIZED), + TEST(SHORT_PREAMBLE), TEST(ASSOC_AP), +- TEST(WME), TEST(WDS), TEST(CLEAR_PS_FILT), ++ TEST(WME), TEST(CLEAR_PS_FILT), + TEST(MFP), TEST(BLOCK_BA), TEST(PSPOLL), + TEST(UAPSD), TEST(SP), TEST(TDLS_PEER), + TEST(TDLS_PEER_AUTH)); +--- a/net/mac80211/ht.c ++++ b/net/mac80211/ht.c +@@ -199,6 +199,8 @@ void ieee80211_send_delba(struct ieee802 + memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); + else if (sdata->vif.type == NL80211_IFTYPE_STATION) + memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); ++ else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) ++ memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN); + + mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | + IEEE80211_STYPE_ACTION); --- a/net/mac80211/ibss.c +++ b/net/mac80211/ibss.c -@@ -661,7 +661,6 @@ static void ieee80211_sta_find_ibss(stru - static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata, - struct sk_buff *req) +@@ -77,6 +77,7 @@ static void __ieee80211_sta_join_ibss(st + struct cfg80211_bss *bss; + u32 bss_change; + u8 supp_rates[IEEE80211_MAX_SUPP_RATES]; ++ enum nl80211_channel_type channel_type; + + lockdep_assert_held(&ifibss->mtx); + +@@ -104,8 +105,16 @@ static void __ieee80211_sta_join_ibss(st + + sdata->drop_unencrypted = capability & WLAN_CAPABILITY_PRIVACY ? 1 : 0; + +- local->oper_channel = chan; +- WARN_ON(!ieee80211_set_channel_type(local, sdata, NL80211_CHAN_NO_HT)); ++ channel_type = ifibss->channel_type; ++ if (channel_type > NL80211_CHAN_HT20 && ++ !cfg80211_can_beacon_sec_chan(local->hw.wiphy, chan, channel_type)) ++ channel_type = NL80211_CHAN_HT20; ++ if (!ieee80211_set_channel_type(local, sdata, channel_type)) { ++ /* can only fail due to HT40+/- mismatch */ ++ channel_type = NL80211_CHAN_HT20; ++ WARN_ON(!ieee80211_set_channel_type(local, sdata, ++ NL80211_CHAN_HT20)); ++ } + ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL); + + sband = local->hw.wiphy->bands[chan->band]; +@@ -171,6 +180,18 @@ static void __ieee80211_sta_join_ibss(st + memcpy(skb_put(skb, ifibss->ie_len), + ifibss->ie, ifibss->ie_len); + ++ /* add HT capability and information IEs */ ++ if (channel_type && sband->ht_cap.ht_supported) { ++ pos = skb_put(skb, 4 + ++ sizeof(struct ieee80211_ht_cap) + ++ sizeof(struct ieee80211_ht_info)); ++ pos = ieee80211_ie_build_ht_cap(pos, sband, sband->ht_cap.cap); ++ pos = ieee80211_ie_build_ht_info(pos, ++ &sband->ht_cap, ++ chan, ++ channel_type); ++ } ++ + if (local->hw.queues >= 4) { + pos = skb_put(skb, 9); + *pos++ = WLAN_EID_VENDOR_SPECIFIC; +@@ -194,6 +215,7 @@ static void __ieee80211_sta_join_ibss(st + bss_change |= BSS_CHANGED_BEACON; + bss_change |= BSS_CHANGED_BEACON_ENABLED; + bss_change |= BSS_CHANGED_BASIC_RATES; ++ bss_change |= BSS_CHANGED_HT; + bss_change |= BSS_CHANGED_IBSS; + sdata->vif.bss_conf.ibss_joined = true; + ieee80211_bss_info_change_notify(sdata, bss_change); +@@ -266,6 +288,7 @@ static void ieee80211_rx_bss_info(struct + u64 beacon_timestamp, rx_timestamp; + u32 supp_rates = 0; + enum ieee80211_band band = rx_status->band; ++ struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band]; + + if (elems->ds_params && elems->ds_params_len == 1) + freq = ieee80211_channel_to_frequency(elems->ds_params[0], +@@ -275,7 +298,10 @@ static void ieee80211_rx_bss_info(struct + + channel = ieee80211_get_channel(local->hw.wiphy, freq); + +- if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) ++ if (!channel || ++ channel->flags & (IEEE80211_CHAN_DISABLED || ++ IEEE80211_CHAN_NO_IBSS || ++ IEEE80211_CHAN_RADAR)) + return; + + if (sdata->vif.type == NL80211_IFTYPE_ADHOC && +@@ -313,8 +339,41 @@ static void ieee80211_rx_bss_info(struct + GFP_ATOMIC); + } + +- if (sta && elems->wmm_info) +- set_sta_flag(sta, WLAN_STA_WME); ++ if (sta) { ++ if (elems->wmm_info) ++ set_sta_flag(sta, WLAN_STA_WME); ++ ++ /* we both use HT */ ++ if (elems->ht_info_elem && elems->ht_cap_elem && ++ sdata->u.ibss.channel_type) { ++ enum nl80211_channel_type channel_type = ++ ieee80211_ht_info_to_channel_type( ++ elems->ht_info_elem); ++ struct ieee80211_sta_ht_cap sta_ht_cap_new; ++ ++ /* ++ * fall back to HT20 if we don't use or use ++ * the other extension channel ++ */ ++ if (channel_type > NL80211_CHAN_HT20 && ++ channel_type != sdata->u.ibss.channel_type) ++ channel_type = NL80211_CHAN_HT20; ++ ++ ieee80211_ht_cap_ie_to_sta_ht_cap(sband, ++ elems->ht_cap_elem, ++ &sta_ht_cap_new); ++ if (memcmp(&sta->sta.ht_cap, &sta_ht_cap_new, ++ sizeof(sta_ht_cap_new))) { ++ memcpy(&sta->sta.ht_cap, ++ &sta_ht_cap_new, ++ sizeof(sta_ht_cap_new)); ++ rate_control_rate_update(local, sband, ++ sta, ++ IEEE80211_RC_HT_CHANGED, ++ channel_type); ++ } ++ } ++ } + + rcu_read_unlock(); + } +@@ -896,10 +955,15 @@ int ieee80211_ibss_join(struct ieee80211 + struct sk_buff *skb; + + skb = dev_alloc_skb(sdata->local->hw.extra_tx_headroom + +- 36 /* bitrates */ + +- 34 /* SSID */ + +- 3 /* DS params */ + +- 4 /* IBSS params */ + ++ sizeof(struct ieee80211_hdr_3addr) + ++ 12 /* struct ieee80211_mgmt.u.beacon */ + ++ 2 + IEEE80211_MAX_SSID_LEN /* max SSID */ + ++ 2 + 8 /* max Supported Rates */ + ++ 3 /* max DS params */ + ++ 4 /* IBSS params */ + ++ 2 + (IEEE80211_MAX_SUPP_RATES - 8) + ++ 2 + sizeof(struct ieee80211_ht_cap) + ++ 2 + sizeof(struct ieee80211_ht_info) + + params->ie_len); + if (!skb) + return -ENOMEM; +@@ -920,13 +984,15 @@ int ieee80211_ibss_join(struct ieee80211 + sdata->vif.bss_conf.beacon_int = params->beacon_interval; + + sdata->u.ibss.channel = params->channel; ++ sdata->u.ibss.channel_type = params->channel_type; + sdata->u.ibss.fixed_channel = params->channel_fixed; + + /* fix ourselves to that channel now already */ + if (params->channel_fixed) { + sdata->local->oper_channel = params->channel; +- WARN_ON(!ieee80211_set_channel_type(sdata->local, sdata, +- NL80211_CHAN_NO_HT)); ++ if (!ieee80211_set_channel_type(sdata->local, sdata, ++ params->channel_type)) ++ return -EINVAL; + } + + if (params->ie) { +--- a/net/mac80211/ieee80211_i.h ++++ b/net/mac80211/ieee80211_i.h +@@ -465,6 +465,7 @@ struct ieee80211_if_ibss { + u8 ssid_len, ie_len; + u8 *ie; + struct ieee80211_channel *channel; ++ enum nl80211_channel_type channel_type; + + unsigned long ibss_join_req; + /* probe response/beacon for IBSS */ +@@ -1339,6 +1340,12 @@ void ieee80211_recalc_smps(struct ieee80 + size_t ieee80211_ie_split(const u8 *ies, size_t ielen, + const u8 *ids, int n_ids, size_t offset); + size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset); ++u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_supported_band *sband, ++ u16 cap); ++u8 *ieee80211_ie_build_ht_info(u8 *pos, ++ struct ieee80211_sta_ht_cap *ht_cap, ++ struct ieee80211_channel *channel, ++ enum nl80211_channel_type channel_type); + + /* internal work items */ + void ieee80211_work_init(struct ieee80211_local *local); +@@ -1367,6 +1374,8 @@ ieee80211_get_channel_mode(struct ieee80 + bool ieee80211_set_channel_type(struct ieee80211_local *local, + struct ieee80211_sub_if_data *sdata, + enum nl80211_channel_type chantype); ++enum nl80211_channel_type ++ieee80211_ht_info_to_channel_type(struct ieee80211_ht_info *ht_info); + + #ifdef CONFIG_MAC80211_NOINLINE + #define debug_noinline noinline +--- a/net/mac80211/iface.c ++++ b/net/mac80211/iface.c +@@ -178,7 +178,6 @@ static int ieee80211_do_open(struct net_ { -- struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(req); - struct ieee80211_mgmt *mgmt = (void *)req->data; - struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; + struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); struct ieee80211_local *local = sdata->local; -@@ -685,7 +684,7 @@ static void ieee80211_rx_mgmt_probe_req( - mgmt->bssid, tx_last_beacon); - #endif /* CONFIG_MAC80211_IBSS_DEBUG */ +- struct sta_info *sta; + u32 changed = 0; + int res; + u32 hw_reconf_flags = 0; +@@ -290,27 +289,6 @@ static int ieee80211_do_open(struct net_ -- if (!tx_last_beacon && !(rx_status->rx_flags & IEEE80211_RX_RA_MATCH)) -+ if (!tx_last_beacon && is_multicast_ether_addr(mgmt->da)) - return; + set_bit(SDATA_STATE_RUNNING, &sdata->state); - if (memcmp(mgmt->bssid, ifibss->bssid, ETH_ALEN) != 0 && ---- a/net/mac80211/rc80211_minstrel_ht.c -+++ b/net/mac80211/rc80211_minstrel_ht.c -@@ -659,18 +659,14 @@ minstrel_ht_update_caps(void *priv, stru - struct ieee80211_mcs_info *mcs = &sta->ht_cap.mcs; - struct ieee80211_local *local = hw_to_local(mp->hw); - u16 sta_cap = sta->ht_cap.cap; -+ int n_supported = 0; - int ack_dur; - int stbc; - int i; - - /* fall back to the old minstrel for legacy stations */ -- if (!sta->ht_cap.ht_supported) { -- msp->is_ht = false; -- memset(&msp->legacy, 0, sizeof(msp->legacy)); -- msp->legacy.r = msp->ratelist; -- msp->legacy.sample_table = msp->sample_table; -- return mac80211_minstrel.rate_init(priv, sband, sta, &msp->legacy); +- if (sdata->vif.type == NL80211_IFTYPE_WDS) { +- /* Create STA entry for the WDS peer */ +- sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, +- GFP_KERNEL); +- if (!sta) { +- res = -ENOMEM; +- goto err_del_interface; +- } +- +- /* no atomic bitop required since STA is not live yet */ +- set_sta_flag(sta, WLAN_STA_AUTHORIZED); +- +- res = sta_info_insert(sta); +- if (res) { +- /* STA has been freed */ +- goto err_del_interface; +- } +- +- rate_control_rate_init(sta); - } -+ if (!sta->ht_cap.ht_supported) -+ goto use_legacy; +- + /* + * set_multicast_list will be invoked by the networking core + * which will check whether any increments here were done in +@@ -344,8 +322,7 @@ static int ieee80211_do_open(struct net_ + netif_tx_start_all_queues(dev); - BUILD_BUG_ON(ARRAY_SIZE(minstrel_mcs_groups) != - MINSTREL_MAX_STREAMS * MINSTREL_STREAM_GROUPS); -@@ -725,7 +721,22 @@ minstrel_ht_update_caps(void *priv, stru + return 0; +- err_del_interface: +- drv_remove_interface(local, &sdata->vif); ++ + err_stop: + if (!local->open_count) + drv_stop(local); +@@ -716,6 +693,70 @@ static void ieee80211_if_setup(struct ne + dev->destructor = free_netdev; + } - mi->groups[i].supported = - mcs->rx_mask[minstrel_mcs_groups[i].streams - 1]; ++static void ieee80211_wds_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, ++ struct sk_buff *skb) ++{ ++ struct ieee80211_local *local = sdata->local; ++ struct ieee80211_rx_status *rx_status; ++ struct ieee802_11_elems elems; ++ struct ieee80211_mgmt *mgmt; ++ struct sta_info *sta; ++ size_t baselen; ++ u32 rates = 0; ++ u16 stype; ++ bool new = false; ++ enum ieee80211_band band = local->hw.conf.channel->band; ++ struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band]; ++ ++ rx_status = IEEE80211_SKB_RXCB(skb); ++ mgmt = (struct ieee80211_mgmt *) skb->data; ++ stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE; ++ ++ if (stype != IEEE80211_STYPE_BEACON) ++ return; ++ ++ baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; ++ if (baselen > skb->len) ++ return; ++ ++ ieee802_11_parse_elems(mgmt->u.probe_resp.variable, ++ skb->len - baselen, &elems); ++ ++ rates = ieee80211_sta_get_rates(local, &elems, band); ++ ++ rcu_read_lock(); ++ ++ sta = sta_info_get(sdata, sdata->u.wds.remote_addr); ++ ++ if (!sta) { ++ rcu_read_unlock(); ++ sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, ++ GFP_KERNEL); ++ if (!sta) ++ return; ++ ++ new = true; ++ } ++ ++ sta->last_rx = jiffies; ++ sta->sta.supp_rates[local->hw.conf.channel->band] = rates; ++ ++ if (elems.ht_cap_elem) ++ ieee80211_ht_cap_ie_to_sta_ht_cap(sband, ++ elems.ht_cap_elem, &sta->sta.ht_cap); + -+ if (mi->groups[i].supported) -+ n_supported++; ++ if (elems.wmm_param) ++ set_sta_flag(sta, WLAN_STA_WME); ++ ++ if (new) { ++ set_sta_flag(sta, WLAN_STA_AUTHORIZED); ++ rate_control_rate_init(sta); ++ sta_info_insert_rcu(sta); ++ } ++ ++ rcu_read_unlock(); ++} ++ + static void ieee80211_iface_work(struct work_struct *work) + { + struct ieee80211_sub_if_data *sdata = +@@ -820,6 +861,9 @@ static void ieee80211_iface_work(struct + break; + ieee80211_mesh_rx_queued_mgmt(sdata, skb); + break; ++ case NL80211_IFTYPE_WDS: ++ ieee80211_wds_rx_queued_mgmt(sdata, skb); ++ break; + default: + WARN(1, "frame for unexpected interface type"); + break; +--- a/net/mac80211/rx.c ++++ b/net/mac80211/rx.c +@@ -2211,7 +2211,9 @@ ieee80211_rx_h_action(struct ieee80211_r + */ + if (sdata->vif.type != NL80211_IFTYPE_STATION && + sdata->vif.type != NL80211_IFTYPE_AP_VLAN && +- sdata->vif.type != NL80211_IFTYPE_AP) ++ sdata->vif.type != NL80211_IFTYPE_AP && ++ sdata->vif.type != NL80211_IFTYPE_ADHOC && ++ sdata->vif.type != NL80211_IFTYPE_WDS) + break; + + /* verify action_code is present */ +@@ -2426,13 +2428,14 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_ + + if (!ieee80211_vif_is_mesh(&sdata->vif) && + sdata->vif.type != NL80211_IFTYPE_ADHOC && +- sdata->vif.type != NL80211_IFTYPE_STATION) ++ sdata->vif.type != NL80211_IFTYPE_STATION && ++ sdata->vif.type != NL80211_IFTYPE_WDS) + return RX_DROP_MONITOR; + + switch (stype) { + case cpu_to_le16(IEEE80211_STYPE_BEACON): + case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP): +- /* process for all: mesh, mlme, ibss */ ++ /* process for all: mesh, mlme, ibss, wds */ + break; + case cpu_to_le16(IEEE80211_STYPE_DEAUTH): + case cpu_to_le16(IEEE80211_STYPE_DISASSOC): +@@ -2775,10 +2778,16 @@ static int prepare_for_handlers(struct i + } + break; + case NL80211_IFTYPE_WDS: +- if (bssid || !ieee80211_is_data(hdr->frame_control)) +- return 0; + if (compare_ether_addr(sdata->u.wds.remote_addr, hdr->addr2)) + return 0; ++ ++ if (ieee80211_is_data(hdr->frame_control) || ++ ieee80211_is_action(hdr->frame_control)) { ++ if (compare_ether_addr(sdata->vif.addr, hdr->addr1)) ++ return 0; ++ } else if (!ieee80211_is_beacon(hdr->frame_control)) ++ return 0; ++ + break; + default: + /* should never get here */ +--- a/net/mac80211/sta_info.h ++++ b/net/mac80211/sta_info.h +@@ -32,7 +32,6 @@ + * frames. + * @WLAN_STA_ASSOC_AP: We're associated to that station, it is an AP. + * @WLAN_STA_WME: Station is a QoS-STA. +- * @WLAN_STA_WDS: Station is one of our WDS peers. + * @WLAN_STA_CLEAR_PS_FILT: Clear PS filter in hardware (using the + * IEEE80211_TX_CTL_CLEAR_PS_FILT control flag) when the next + * frame to this station is transmitted. +@@ -61,7 +60,6 @@ enum ieee80211_sta_info_flags { + WLAN_STA_SHORT_PREAMBLE, + WLAN_STA_ASSOC_AP, + WLAN_STA_WME, +- WLAN_STA_WDS, + WLAN_STA_CLEAR_PS_FILT, + WLAN_STA_MFP, + WLAN_STA_BLOCK_BA, +--- a/net/mac80211/util.c ++++ b/net/mac80211/util.c +@@ -836,23 +836,8 @@ int ieee80211_build_preq_ies(struct ieee + offset = noffset; + } + +- if (sband->ht_cap.ht_supported) { +- u16 cap = sband->ht_cap.cap; +- __le16 tmp; +- +- *pos++ = WLAN_EID_HT_CAPABILITY; +- *pos++ = sizeof(struct ieee80211_ht_cap); +- memset(pos, 0, sizeof(struct ieee80211_ht_cap)); +- tmp = cpu_to_le16(cap); +- memcpy(pos, &tmp, sizeof(u16)); +- pos += sizeof(u16); +- *pos++ = sband->ht_cap.ampdu_factor | +- (sband->ht_cap.ampdu_density << +- IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); +- memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs)); +- pos += sizeof(sband->ht_cap.mcs); +- pos += 2 + 4 + 1; /* ext info, BF cap, antsel */ +- } ++ if (sband->ht_cap.ht_supported) ++ pos = ieee80211_ie_build_ht_cap(pos, sband, sband->ht_cap.cap); + + /* + * If adding more here, adjust code in main.c +@@ -1443,3 +1428,100 @@ int ieee80211_add_ext_srates_ie(struct i } + return 0; + } ++ ++u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_supported_band *sband, ++ u16 cap) ++{ ++ __le16 tmp; ++ ++ *pos++ = WLAN_EID_HT_CAPABILITY; ++ *pos++ = sizeof(struct ieee80211_ht_cap); ++ memset(pos, 0, sizeof(struct ieee80211_ht_cap)); ++ ++ /* capability flags */ ++ tmp = cpu_to_le16(cap); ++ memcpy(pos, &tmp, sizeof(u16)); ++ pos += sizeof(u16); ++ ++ /* AMPDU parameters */ ++ *pos++ = sband->ht_cap.ampdu_factor | ++ (sband->ht_cap.ampdu_density << ++ IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); ++ ++ /* MCS set */ ++ memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs)); ++ pos += sizeof(sband->ht_cap.mcs); ++ ++ /* extended capabilities */ ++ pos += sizeof(__le16); ++ ++ /* BF capabilities */ ++ pos += sizeof(__le32); ++ ++ /* antenna selection */ ++ pos += sizeof(u8); + -+ if (!n_supported) -+ goto use_legacy; ++ return pos; ++} + -+ return; ++u8 *ieee80211_ie_build_ht_info(u8 *pos, ++ struct ieee80211_sta_ht_cap *ht_cap, ++ struct ieee80211_channel *channel, ++ enum nl80211_channel_type channel_type) ++{ ++ struct ieee80211_ht_info *ht_info; ++ /* Build HT Information */ ++ *pos++ = WLAN_EID_HT_INFORMATION; ++ *pos++ = sizeof(struct ieee80211_ht_info); ++ ht_info = (struct ieee80211_ht_info *)pos; ++ ht_info->control_chan = ++ ieee80211_frequency_to_channel(channel->center_freq); ++ switch (channel_type) { ++ case NL80211_CHAN_HT40MINUS: ++ ht_info->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW; ++ break; ++ case NL80211_CHAN_HT40PLUS: ++ ht_info->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; ++ break; ++ case NL80211_CHAN_HT20: ++ default: ++ ht_info->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE; ++ break; ++ } ++ if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ++ ht_info->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY; ++ ht_info->operation_mode = 0x0000; ++ ht_info->stbc_param = 0x0000; + -+use_legacy: -+ msp->is_ht = false; -+ memset(&msp->legacy, 0, sizeof(msp->legacy)); -+ msp->legacy.r = msp->ratelist; -+ msp->legacy.sample_table = msp->sample_table; -+ return mac80211_minstrel.rate_init(priv, sband, sta, &msp->legacy); ++ /* It seems that Basic MCS set and Supported MCS set ++ are identical for the first 10 bytes */ ++ memset(&ht_info->basic_set, 0, 16); ++ memcpy(&ht_info->basic_set, &ht_cap->mcs, 10); ++ ++ return pos + sizeof(struct ieee80211_ht_info); ++} ++ ++enum nl80211_channel_type ++ieee80211_ht_info_to_channel_type(struct ieee80211_ht_info *ht_info) ++{ ++ enum nl80211_channel_type channel_type; ++ ++ if (!ht_info) ++ return NL80211_CHAN_NO_HT; ++ ++ switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { ++ case IEEE80211_HT_PARAM_CHA_SEC_NONE: ++ channel_type = NL80211_CHAN_HT20; ++ break; ++ case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: ++ channel_type = NL80211_CHAN_HT40PLUS; ++ break; ++ case IEEE80211_HT_PARAM_CHA_SEC_BELOW: ++ channel_type = NL80211_CHAN_HT40MINUS; ++ break; ++ default: ++ channel_type = NL80211_CHAN_NO_HT; ++ } ++ ++ return channel_type; ++} +--- a/net/mac80211/work.c ++++ b/net/mac80211/work.c +@@ -118,7 +118,6 @@ static void ieee80211_add_ht_ie(struct s + u8 *pos; + u32 flags = channel->flags; + u16 cap = sband->ht_cap.cap; +- __le16 tmp; + + if (!sband->ht_cap.ht_supported) + return; +@@ -169,34 +168,8 @@ static void ieee80211_add_ht_ie(struct s + } + + /* reserve and fill IE */ +- + pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2); +- *pos++ = WLAN_EID_HT_CAPABILITY; +- *pos++ = sizeof(struct ieee80211_ht_cap); +- memset(pos, 0, sizeof(struct ieee80211_ht_cap)); +- +- /* capability flags */ +- tmp = cpu_to_le16(cap); +- memcpy(pos, &tmp, sizeof(u16)); +- pos += sizeof(u16); +- +- /* AMPDU parameters */ +- *pos++ = sband->ht_cap.ampdu_factor | +- (sband->ht_cap.ampdu_density << +- IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); +- +- /* MCS set */ +- memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs)); +- pos += sizeof(sband->ht_cap.mcs); +- +- /* extended capabilities */ +- pos += sizeof(__le16); +- +- /* BF capabilities */ +- pos += sizeof(__le32); +- +- /* antenna selection */ +- pos += sizeof(u8); ++ ieee80211_ie_build_ht_cap(pos, sband, cap); + } + + static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata, +--- a/net/wireless/chan.c ++++ b/net/wireless/chan.c +@@ -44,9 +44,9 @@ rdev_freq_to_chan(struct cfg80211_regist + return chan; } - static void +-static bool can_beacon_sec_chan(struct wiphy *wiphy, +- struct ieee80211_channel *chan, +- enum nl80211_channel_type channel_type) ++bool cfg80211_can_beacon_sec_chan(struct wiphy *wiphy, ++ struct ieee80211_channel *chan, ++ enum nl80211_channel_type channel_type) + { + struct ieee80211_channel *sec_chan; + int diff; +@@ -75,6 +75,7 @@ static bool can_beacon_sec_chan(struct w + + return true; + } ++EXPORT_SYMBOL(cfg80211_can_beacon_sec_chan); + + int cfg80211_set_freq(struct cfg80211_registered_device *rdev, + struct wireless_dev *wdev, int freq, +@@ -109,8 +110,8 @@ int cfg80211_set_freq(struct cfg80211_re + switch (channel_type) { + case NL80211_CHAN_HT40PLUS: + case NL80211_CHAN_HT40MINUS: +- if (!can_beacon_sec_chan(&rdev->wiphy, chan, +- channel_type)) { ++ if (!cfg80211_can_beacon_sec_chan(&rdev->wiphy, chan, ++ channel_type)) { + printk(KERN_DEBUG + "cfg80211: Secondary channel not " + "allowed to initiate communication\n"); +--- a/net/wireless/nl80211.c ++++ b/net/wireless/nl80211.c +@@ -4574,13 +4574,34 @@ static int nl80211_join_ibss(struct sk_b + ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); + } + +- ibss.channel = ieee80211_get_channel(wiphy, +- nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ])); ++ if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) { ++ enum nl80211_channel_type channel_type; ++ ++ channel_type = nla_get_u32( ++ info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]); ++ if (channel_type > NL80211_CHAN_HT40PLUS) ++ return -EINVAL; ++ ibss.channel_type = channel_type; ++ } else { ++ ibss.channel_type = NL80211_CHAN_NO_HT; ++ } ++ ++ ibss.channel = rdev_freq_to_chan(rdev, ++ nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]), ++ ibss.channel_type); + if (!ibss.channel || ++ ibss.channel->flags & IEEE80211_CHAN_RADAR || + ibss.channel->flags & IEEE80211_CHAN_NO_IBSS || + ibss.channel->flags & IEEE80211_CHAN_DISABLED) + return -EINVAL; + ++ /* Both channels should be able to initiate communication */ ++ if ((ibss.channel_type == NL80211_CHAN_HT40PLUS || ++ ibss.channel_type == NL80211_CHAN_HT40MINUS) && ++ !cfg80211_can_beacon_sec_chan(&rdev->wiphy, ibss.channel, ++ ibss.channel_type)) ++ return -EINVAL; ++ + ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED]; + ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY]; +