Merge branch 'for-davem' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next

John W. Linville says:

====================
Please pull this batch of updates intended for the 3.14 stream...

For the mac80211 bits, Johannes says:

"I have various improvements/cleanups/fixes all over, but the shortlog
shows that Luis's regulatory work and mesh work from the cozybit folks
are the biggest ones, along with the CSA fixes."

Along with that, we have big batches of updates to brcmfmac, rtlwifi,
and ath9k.  There are updates to wcn36xx, rt2x00, and a handful of
others as well.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

46 files changed, 2460 insertions, 1092 deletions

diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index 364ce0c5962f..f80e8c4c6bcd 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -133,7 +133,9 @@ static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
                              struct key_params *params)
 {
         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+        struct ieee80211_local *local = sdata->local;
         struct sta_info *sta = NULL;
+        const struct ieee80211_cipher_scheme *cs = NULL;
         struct ieee80211_key *key;
         int err;
 
@@ -145,22 +147,28 @@ static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
         case WLAN_CIPHER_SUITE_WEP40:
         case WLAN_CIPHER_SUITE_TKIP:
         case WLAN_CIPHER_SUITE_WEP104:
-                if (IS_ERR(sdata->local->wep_tx_tfm))
+                if (IS_ERR(local->wep_tx_tfm))
                         return -EINVAL;
                 break;
+        case WLAN_CIPHER_SUITE_CCMP:
+        case WLAN_CIPHER_SUITE_AES_CMAC:
+        case WLAN_CIPHER_SUITE_GCMP:
+                break;
         default:
+                cs = ieee80211_cs_get(local, params->cipher, sdata->vif.type);
                 break;
         }
 
         key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
-                                  params->key, params->seq_len, params->seq);
+                                  params->key, params->seq_len, params->seq,
+                                  cs);
         if (IS_ERR(key))
                 return PTR_ERR(key);
 
         if (pairwise)
                 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
 
-        mutex_lock(&sdata->local->sta_mtx);
+        mutex_lock(&local->sta_mtx);
 
         if (mac_addr) {
                 if (ieee80211_vif_is_mesh(&sdata->vif))
@@ -216,10 +224,13 @@ static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
                 break;
         }
 
+        if (sta)
+                sta->cipher_scheme = cs;
+
         err = ieee80211_key_link(key, sdata, sta);
 
  out_unlock:
-        mutex_unlock(&sdata->local->sta_mtx);
+        mutex_unlock(&local->sta_mtx);
 
         return err;
 }
@@ -244,7 +255,7 @@ static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
                         goto out_unlock;
 
                 if (pairwise)
-                        key = key_mtx_dereference(local, sta->ptk);
+                        key = key_mtx_dereference(local, sta->ptk[key_idx]);
                 else
                         key = key_mtx_dereference(local, sta->gtk[key_idx]);
         } else
@@ -291,7 +302,7 @@ static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
                         goto out;
 
                 if (pairwise)
-                        key = rcu_dereference(sta->ptk);
+                        key = rcu_dereference(sta->ptk[key_idx]);
                 else if (key_idx < NUM_DEFAULT_KEYS)
                         key = rcu_dereference(sta->gtk[key_idx]);
         } else
@@ -521,8 +532,8 @@ static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
                                  STATION_INFO_PEER_PM |
                                  STATION_INFO_NONPEER_PM;
 
-                sinfo->llid = le16_to_cpu(sta->llid);
-                sinfo->plid = le16_to_cpu(sta->plid);
+                sinfo->llid = sta->llid;
+                sinfo->plid = sta->plid;
                 sinfo->plink_state = sta->plink_state;
                 if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
                         sinfo->filled |= STATION_INFO_T_OFFSET;
@@ -846,7 +857,7 @@ static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
         if (!resp || !resp_len)
                 return 1;
 
-        old = rtnl_dereference(sdata->u.ap.probe_resp);
+        old = sdata_dereference(sdata->u.ap.probe_resp, sdata);
 
         new = kzalloc(sizeof(struct probe_resp) + resp_len, GFP_KERNEL);
         if (!new)
@@ -870,7 +881,8 @@ int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
         int size, err;
         u32 changed = BSS_CHANGED_BEACON;
 
-        old = rtnl_dereference(sdata->u.ap.beacon);
+        old = sdata_dereference(sdata->u.ap.beacon, sdata);
+
 
         /* Need to have a beacon head if we don't have one yet */
         if (!params->head && !old)
@@ -947,7 +959,7 @@ static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
                       BSS_CHANGED_P2P_PS;
         int err;
 
-        old = rtnl_dereference(sdata->u.ap.beacon);
+        old = sdata_dereference(sdata->u.ap.beacon, sdata);
         if (old)
                 return -EALREADY;
 
@@ -968,11 +980,19 @@ static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
          */
         sdata->control_port_protocol = params->crypto.control_port_ethertype;
         sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt;
+        sdata->encrypt_headroom = ieee80211_cs_headroom(sdata->local,
+                                                        &params->crypto,
+                                                        sdata->vif.type);
+
         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
                 vlan->control_port_protocol =
                         params->crypto.control_port_ethertype;
                 vlan->control_port_no_encrypt =
                         params->crypto.control_port_no_encrypt;
+                vlan->encrypt_headroom =
+                        ieee80211_cs_headroom(sdata->local,
+                                              &params->crypto,
+                                              vlan->vif.type);
         }
 
         sdata->vif.bss_conf.beacon_int = params->beacon_interval;
@@ -1001,7 +1021,8 @@ static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
 
         err = drv_start_ap(sdata->local, sdata);
         if (err) {
-                old = rtnl_dereference(sdata->u.ap.beacon);
+                old = sdata_dereference(sdata->u.ap.beacon, sdata);
+
                 if (old)
                         kfree_rcu(old, rcu_head);
                 RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
@@ -1032,7 +1053,7 @@ static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
         if (sdata->vif.csa_active)
                 return -EBUSY;
 
-        old = rtnl_dereference(sdata->u.ap.beacon);
+        old = sdata_dereference(sdata->u.ap.beacon, sdata);
         if (!old)
                 return -ENOENT;
 
@@ -1050,15 +1071,18 @@ static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
         struct ieee80211_local *local = sdata->local;
         struct beacon_data *old_beacon;
         struct probe_resp *old_probe_resp;
+        struct cfg80211_chan_def chandef;
 
-        old_beacon = rtnl_dereference(sdata->u.ap.beacon);
+        old_beacon = sdata_dereference(sdata->u.ap.beacon, sdata);
         if (!old_beacon)
                 return -ENOENT;
-        old_probe_resp = rtnl_dereference(sdata->u.ap.probe_resp);
+        old_probe_resp = sdata_dereference(sdata->u.ap.probe_resp, sdata);
 
         /* abort any running channel switch */
         sdata->vif.csa_active = false;
-        cancel_work_sync(&sdata->csa_finalize_work);
+        kfree(sdata->u.ap.next_beacon);
+        sdata->u.ap.next_beacon = NULL;
+
         cancel_work_sync(&sdata->u.ap.request_smps_work);
 
         /* turn off carrier for this interface and dependent VLANs */
@@ -1091,8 +1115,10 @@ static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
 
         if (sdata->wdev.cac_started) {
+                chandef = sdata->vif.bss_conf.chandef;
                 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
-                cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,
+                cfg80211_cac_event(sdata->dev, &chandef,
+                                   NL80211_RADAR_CAC_ABORTED,
                                    GFP_KERNEL);
         }
 
@@ -1953,7 +1979,7 @@ static int ieee80211_change_bss(struct wiphy *wiphy,
         enum ieee80211_band band;
         u32 changed = 0;
 
-        if (!rtnl_dereference(sdata->u.ap.beacon))
+        if (!sdata_dereference(sdata->u.ap.beacon, sdata))
                 return -ENOENT;
 
         band = ieee80211_get_sdata_band(sdata);
@@ -2963,27 +2989,33 @@ void ieee80211_csa_finalize_work(struct work_struct *work)
         struct ieee80211_local *local = sdata->local;
         int err, changed = 0;
 
+        sdata_lock(sdata);
+        /* AP might have been stopped while waiting for the lock. */
+        if (!sdata->vif.csa_active)
+                goto unlock;
+
         if (!ieee80211_sdata_running(sdata))
-                return;
+                goto unlock;
 
         sdata->radar_required = sdata->csa_radar_required;
-        err = ieee80211_vif_change_channel(sdata, &local->csa_chandef,
-                                           &changed);
+        err = ieee80211_vif_change_channel(sdata, &changed);
         if (WARN_ON(err < 0))
-                return;
+                goto unlock;
 
         if (!local->use_chanctx) {
-                local->_oper_chandef = local->csa_chandef;
+                local->_oper_chandef = sdata->csa_chandef;
                 ieee80211_hw_config(local, 0);
         }
 
         ieee80211_bss_info_change_notify(sdata, changed);
 
+        sdata->vif.csa_active = false;
         switch (sdata->vif.type) {
         case NL80211_IFTYPE_AP:
                 err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon);
                 if (err < 0)
-                        return;
+                        goto unlock;
+
                 changed |= err;
                 kfree(sdata->u.ap.next_beacon);
                 sdata->u.ap.next_beacon = NULL;
@@ -2997,20 +3029,22 @@ void ieee80211_csa_finalize_work(struct work_struct *work)
         case NL80211_IFTYPE_MESH_POINT:
                 err = ieee80211_mesh_finish_csa(sdata);
                 if (err < 0)
-                        return;
+                        goto unlock;
                 break;
 #endif
         default:
                 WARN_ON(1);
-                return;
+                goto unlock;
         }
-        sdata->vif.csa_active = false;
 
         ieee80211_wake_queues_by_reason(&sdata->local->hw,
                                         IEEE80211_MAX_QUEUE_MAP,
                                         IEEE80211_QUEUE_STOP_REASON_CSA);
 
-        cfg80211_ch_switch_notify(sdata->dev, &local->csa_chandef);
+        cfg80211_ch_switch_notify(sdata->dev, &sdata->csa_chandef);
+
+unlock:
+        sdata_unlock(sdata);
 }
 
 static int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
@@ -3023,6 +3057,8 @@ static int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
         struct ieee80211_if_mesh __maybe_unused *ifmsh;
         int err, num_chanctx;
 
+        lockdep_assert_held(&sdata->wdev.mtx);
+
         if (!list_empty(&local->roc_list) || local->scanning)
                 return -EBUSY;
 
@@ -3143,7 +3179,7 @@ static int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
                                 IEEE80211_MAX_QUEUE_MAP,
                                 IEEE80211_QUEUE_STOP_REASON_CSA);
 
-        local->csa_chandef = params->chandef;
+        sdata->csa_chandef = params->chandef;
         sdata->vif.csa_active = true;
 
         ieee80211_bss_info_change_notify(sdata, err);
@@ -3153,26 +3189,25 @@ static int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
 }
 
 static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
-                             struct ieee80211_channel *chan, bool offchan,
-                             unsigned int wait, const u8 *buf, size_t len,
-                             bool no_cck, bool dont_wait_for_ack, u64 *cookie)
+                             struct cfg80211_mgmt_tx_params *params,
+                             u64 *cookie)
 {
         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
         struct ieee80211_local *local = sdata->local;
         struct sk_buff *skb;
         struct sta_info *sta;
-        const struct ieee80211_mgmt *mgmt = (void *)buf;
+        const struct ieee80211_mgmt *mgmt = (void *)params->buf;
         bool need_offchan = false;
         u32 flags;
         int ret;
 
-        if (dont_wait_for_ack)
+        if (params->dont_wait_for_ack)
                 flags = IEEE80211_TX_CTL_NO_ACK;
         else
                 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
                         IEEE80211_TX_CTL_REQ_TX_STATUS;
 
-        if (no_cck)
+        if (params->no_cck)
                 flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
 
         switch (sdata->vif.type) {
@@ -3220,7 +3255,7 @@ static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
         /* configurations requiring offchan cannot work if no channel has been
          * specified
          */
-        if (need_offchan && !chan)
+        if (need_offchan && !params->chan)
                 return -EINVAL;
 
         mutex_lock(&local->mtx);
@@ -3233,8 +3268,10 @@ static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
                 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
 
                 if (chanctx_conf) {
-                        need_offchan = chan && (chan != chanctx_conf->def.chan);
-                } else if (!chan) {
+                        need_offchan = params->chan &&
+                                       (params->chan !=
+                                        chanctx_conf->def.chan);
+                } else if (!params->chan) {
                         ret = -EINVAL;
                         rcu_read_unlock();
                         goto out_unlock;
@@ -3244,19 +3281,19 @@ static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
                 rcu_read_unlock();
         }
 
-        if (need_offchan && !offchan) {
+        if (need_offchan && !params->offchan) {
                 ret = -EBUSY;
                 goto out_unlock;
         }
 
-        skb = dev_alloc_skb(local->hw.extra_tx_headroom + len);
+        skb = dev_alloc_skb(local->hw.extra_tx_headroom + params->len);
         if (!skb) {
                 ret = -ENOMEM;
                 goto out_unlock;
         }
         skb_reserve(skb, local->hw.extra_tx_headroom);
 
-        memcpy(skb_put(skb, len), buf, len);
+        memcpy(skb_put(skb, params->len), params->buf, params->len);
 
         IEEE80211_SKB_CB(skb)->flags = flags;
 
@@ -3276,8 +3313,8 @@ static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
                         local->hw.offchannel_tx_hw_queue;
 
         /* This will handle all kinds of coalescing and immediate TX */
-        ret = ieee80211_start_roc_work(local, sdata, chan,
-                                       wait, cookie, skb,
+        ret = ieee80211_start_roc_work(local, sdata, params->chan,
+                                       params->wait, cookie, skb,
                                        IEEE80211_ROC_TYPE_MGMT_TX);
         if (ret)
                 kfree_skb(skb);
diff --git a/net/mac80211/chan.c b/net/mac80211/chan.c
index 03ba6b5c5373..a57d5d9466bc 100644
--- a/net/mac80211/chan.c
+++ b/net/mac80211/chan.c
@@ -9,6 +9,140 @@
 #include "ieee80211_i.h"
 #include "driver-ops.h"
 
+static enum nl80211_chan_width ieee80211_get_sta_bw(struct ieee80211_sta *sta)
+{
+        switch (sta->bandwidth) {
+        case IEEE80211_STA_RX_BW_20:
+                if (sta->ht_cap.ht_supported)
+                        return NL80211_CHAN_WIDTH_20;
+                else
+                        return NL80211_CHAN_WIDTH_20_NOHT;
+        case IEEE80211_STA_RX_BW_40:
+                return NL80211_CHAN_WIDTH_40;
+        case IEEE80211_STA_RX_BW_80:
+                return NL80211_CHAN_WIDTH_80;
+        case IEEE80211_STA_RX_BW_160:
+                /*
+                 * This applied for both 160 and 80+80. since we use
+                 * the returned value to consider degradation of
+                 * ctx->conf.min_def, we have to make sure to take
+                 * the bigger one (NL80211_CHAN_WIDTH_160).
+                 * Otherwise we might try degrading even when not
+                 * needed, as the max required sta_bw returned (80+80)
+                 * might be smaller than the configured bw (160).
+                 */
+                return NL80211_CHAN_WIDTH_160;
+        default:
+                WARN_ON(1);
+                return NL80211_CHAN_WIDTH_20;
+        }
+}
+
+static enum nl80211_chan_width
+ieee80211_get_max_required_bw(struct ieee80211_sub_if_data *sdata)
+{
+        enum nl80211_chan_width max_bw = NL80211_CHAN_WIDTH_20_NOHT;
+        struct sta_info *sta;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(sta, &sdata->local->sta_list, list) {
+                if (sdata != sta->sdata &&
+                    !(sta->sdata->bss && sta->sdata->bss == sdata->bss))
+                        continue;
+
+                if (!sta->uploaded)
+                        continue;
+
+                max_bw = max(max_bw, ieee80211_get_sta_bw(&sta->sta));
+        }
+        rcu_read_unlock();
+
+        return max_bw;
+}
+
+static enum nl80211_chan_width
+ieee80211_get_chanctx_max_required_bw(struct ieee80211_local *local,
+                                      struct ieee80211_chanctx_conf *conf)
+{
+        struct ieee80211_sub_if_data *sdata;
+        enum nl80211_chan_width max_bw = NL80211_CHAN_WIDTH_20_NOHT;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(sdata, &local->interfaces, list) {
+                struct ieee80211_vif *vif = &sdata->vif;
+                enum nl80211_chan_width width = NL80211_CHAN_WIDTH_20_NOHT;
+
+                if (!ieee80211_sdata_running(sdata))
+                        continue;
+
+                if (rcu_access_pointer(sdata->vif.chanctx_conf) != conf)
+                        continue;
+
+                switch (vif->type) {
+                case NL80211_IFTYPE_AP:
+                case NL80211_IFTYPE_AP_VLAN:
+                        width = ieee80211_get_max_required_bw(sdata);
+                        break;
+                case NL80211_IFTYPE_P2P_DEVICE:
+                        continue;
+                case NL80211_IFTYPE_STATION:
+                case NL80211_IFTYPE_ADHOC:
+                case NL80211_IFTYPE_WDS:
+                case NL80211_IFTYPE_MESH_POINT:
+                        width = vif->bss_conf.chandef.width;
+                        break;
+                case NL80211_IFTYPE_UNSPECIFIED:
+                case NUM_NL80211_IFTYPES:
+                case NL80211_IFTYPE_MONITOR:
+                case NL80211_IFTYPE_P2P_CLIENT:
+                case NL80211_IFTYPE_P2P_GO:
+                        WARN_ON_ONCE(1);
+                }
+                max_bw = max(max_bw, width);
+        }
+        rcu_read_unlock();
+
+        return max_bw;
+}
+
+/*
+ * recalc the min required chan width of the channel context, which is
+ * the max of min required widths of all the interfaces bound to this
+ * channel context.
+ */
+void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
+                                      struct ieee80211_chanctx *ctx)
+{
+        enum nl80211_chan_width max_bw;
+        struct cfg80211_chan_def min_def;
+
+        lockdep_assert_held(&local->chanctx_mtx);
+
+        /* don't optimize 5MHz, 10MHz, and radar_enabled confs */
+        if (ctx->conf.def.width == NL80211_CHAN_WIDTH_5 ||
+            ctx->conf.def.width == NL80211_CHAN_WIDTH_10 ||
+            ctx->conf.radar_enabled) {
+                ctx->conf.min_def = ctx->conf.def;
+                return;
+        }
+
+        max_bw = ieee80211_get_chanctx_max_required_bw(local, &ctx->conf);
+
+        /* downgrade chandef up to max_bw */
+        min_def = ctx->conf.def;
+        while (min_def.width > max_bw)
+                ieee80211_chandef_downgrade(&min_def);
+
+        if (cfg80211_chandef_identical(&ctx->conf.min_def, &min_def))
+                return;
+
+        ctx->conf.min_def = min_def;
+        if (!ctx->driver_present)
+                return;
+
+        drv_change_chanctx(local, ctx, IEEE80211_CHANCTX_CHANGE_MIN_WIDTH);
+}
+
 static void ieee80211_change_chanctx(struct ieee80211_local *local,
                                      struct ieee80211_chanctx *ctx,
                                      const struct cfg80211_chan_def *chandef)
@@ -20,6 +154,7 @@ static void ieee80211_change_chanctx(struct ieee80211_local *local,
 
         ctx->conf.def = *chandef;
         drv_change_chanctx(local, ctx, IEEE80211_CHANCTX_CHANGE_WIDTH);
+        ieee80211_recalc_chanctx_min_def(local, ctx);
 
         if (!local->use_chanctx) {
                 local->_oper_chandef = *chandef;
@@ -93,6 +228,7 @@ ieee80211_new_chanctx(struct ieee80211_local *local,
         ctx->conf.rx_chains_dynamic = 1;
         ctx->mode = mode;
         ctx->conf.radar_enabled = ieee80211_is_radar_required(local);
+        ieee80211_recalc_chanctx_min_def(local, ctx);
         if (!local->use_chanctx)
                 local->hw.conf.radar_enabled = ctx->conf.radar_enabled;
 
@@ -179,6 +315,7 @@ static int ieee80211_assign_vif_chanctx(struct ieee80211_sub_if_data *sdata,
         ctx->refcount++;
 
         ieee80211_recalc_txpower(sdata);
+        ieee80211_recalc_chanctx_min_def(local, ctx);
         sdata->vif.bss_conf.idle = false;
 
         if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
@@ -243,6 +380,7 @@ static void ieee80211_unassign_vif_chanctx(struct ieee80211_sub_if_data *sdata,
                 ieee80211_recalc_chanctx_chantype(sdata->local, ctx);
                 ieee80211_recalc_smps_chanctx(local, ctx);
                 ieee80211_recalc_radar_chanctx(local, ctx);
+                ieee80211_recalc_chanctx_min_def(local, ctx);
         }
 }
 
@@ -411,12 +549,12 @@ int ieee80211_vif_use_channel(struct ieee80211_sub_if_data *sdata,
 }
 
 int ieee80211_vif_change_channel(struct ieee80211_sub_if_data *sdata,
-                                 const struct cfg80211_chan_def *chandef,
                                  u32 *changed)
 {
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_chanctx_conf *conf;
         struct ieee80211_chanctx *ctx;
+        const struct cfg80211_chan_def *chandef = &sdata->csa_chandef;
         int ret;
         u32 chanctx_changed = 0;
 
@@ -456,6 +594,7 @@ int ieee80211_vif_change_channel(struct ieee80211_sub_if_data *sdata,
         ieee80211_recalc_chanctx_chantype(local, ctx);
         ieee80211_recalc_smps_chanctx(local, ctx);
         ieee80211_recalc_radar_chanctx(local, ctx);
+        ieee80211_recalc_chanctx_min_def(local, ctx);
 
         ret = 0;
  out:
diff --git a/net/mac80211/debugfs.c b/net/mac80211/debugfs.c
index 5c090e41d9bb..fa16e54980a1 100644
--- a/net/mac80211/debugfs.c
+++ b/net/mac80211/debugfs.c
@@ -17,6 +17,172 @@
 
 #define DEBUGFS_FORMAT_BUFFER_SIZE 100
 
+#define TX_LATENCY_BIN_DELIMTER_C ','
+#define TX_LATENCY_BIN_DELIMTER_S ","
+#define TX_LATENCY_BINS_DISABLED "enable(bins disabled)\n"
+#define TX_LATENCY_DISABLED "disable\n"
+
+
+/*
+ * Display if Tx latency statistics & bins are enabled/disabled
+ */
+static ssize_t sta_tx_latency_stat_read(struct file *file,
+                                        char __user *userbuf,
+                                        size_t count, loff_t *ppos)
+{
+        struct ieee80211_local *local = file->private_data;
+        struct ieee80211_tx_latency_bin_ranges  *tx_latency;
+        char *buf;
+        int bufsz, i, ret;
+        int pos = 0;
+
+        rcu_read_lock();
+
+        tx_latency = rcu_dereference(local->tx_latency);
+
+        if (tx_latency && tx_latency->n_ranges) {
+                bufsz = tx_latency->n_ranges * 15;
+                buf = kzalloc(bufsz, GFP_ATOMIC);
+                if (!buf)
+                        goto err;
+
+                for (i = 0; i < tx_latency->n_ranges; i++)
+                        pos += scnprintf(buf + pos, bufsz - pos, "%d,",
+                                         tx_latency->ranges[i]);
+                pos += scnprintf(buf + pos, bufsz - pos, "\n");
+        } else if (tx_latency) {
+                bufsz = sizeof(TX_LATENCY_BINS_DISABLED) + 1;
+                buf = kzalloc(bufsz, GFP_ATOMIC);
+                if (!buf)
+                        goto err;
+
+                pos += scnprintf(buf + pos, bufsz - pos, "%s\n",
+                                 TX_LATENCY_BINS_DISABLED);
+        } else {
+                bufsz = sizeof(TX_LATENCY_DISABLED) + 1;
+                buf = kzalloc(bufsz, GFP_ATOMIC);
+                if (!buf)
+                        goto err;
+
+                pos += scnprintf(buf + pos, bufsz - pos, "%s\n",
+                                 TX_LATENCY_DISABLED);
+        }
+
+        rcu_read_unlock();
+
+        ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
+        kfree(buf);
+
+        return ret;
+err:
+        rcu_read_unlock();
+        return -ENOMEM;
+}
+
+/*
+ * Receive input from user regarding Tx latency statistics
+ * The input should indicate if Tx latency statistics and bins are
+ * enabled/disabled.
+ * If bins are enabled input should indicate the amount of different bins and
+ * their ranges. Each bin will count how many Tx frames transmitted within the
+ * appropriate latency.
+ * Legal input is:
+ * a) "enable(bins disabled)" - to enable only general statistics
+ * b) "a,b,c,d,...z" - to enable general statistics and bins, where all are
+ * numbers and a < b < c < d.. < z
+ * c) "disable" - disable all statistics
+ * NOTE: must configure Tx latency statistics bins before stations connected.
+ */
+
+static ssize_t sta_tx_latency_stat_write(struct file *file,
+                                         const char __user *userbuf,
+                                         size_t count, loff_t *ppos)
+{
+        struct ieee80211_local *local = file->private_data;
+        char buf[128] = {};
+        char *bins = buf;
+        char *token;
+        int buf_size, i, alloc_size;
+        int prev_bin = 0;
+        int n_ranges = 0;
+        int ret = count;
+        struct ieee80211_tx_latency_bin_ranges  *tx_latency;
+
+        if (sizeof(buf) <= count)
+                return -EINVAL;
+        buf_size = count;
+        if (copy_from_user(buf, userbuf, buf_size))
+                return -EFAULT;
+
+        mutex_lock(&local->sta_mtx);
+
+        /* cannot change config once we have stations */
+        if (local->num_sta)
+                goto unlock;
+
+        tx_latency =
+                rcu_dereference_protected(local->tx_latency,
+                                          lockdep_is_held(&local->sta_mtx));
+
+        /* disable Tx statistics */
+        if (!strcmp(buf, TX_LATENCY_DISABLED)) {
+                if (!tx_latency)
+                        goto unlock;
+                rcu_assign_pointer(local->tx_latency, NULL);
+                synchronize_rcu();
+                kfree(tx_latency);
+                goto unlock;
+        }
+
+        /* Tx latency already enabled */
+        if (tx_latency)
+                goto unlock;
+
+        if (strcmp(TX_LATENCY_BINS_DISABLED, buf)) {
+                /* check how many bins and between what ranges user requested */
+                token = buf;
+                while (*token != '\0') {
+                        if (*token == TX_LATENCY_BIN_DELIMTER_C)
+                                n_ranges++;
+                        token++;
+                }
+                n_ranges++;
+        }
+
+        alloc_size = sizeof(struct ieee80211_tx_latency_bin_ranges) +
+                     n_ranges * sizeof(u32);
+        tx_latency = kzalloc(alloc_size, GFP_ATOMIC);
+        if (!tx_latency) {
+                ret = -ENOMEM;
+                goto unlock;
+        }
+        tx_latency->n_ranges = n_ranges;
+        for (i = 0; i < n_ranges; i++) { /* setting bin ranges */
+                token = strsep(&bins, TX_LATENCY_BIN_DELIMTER_S);
+                sscanf(token, "%d", &tx_latency->ranges[i]);
+                /* bins values should be in ascending order */
+                if (prev_bin >= tx_latency->ranges[i]) {
+                        ret = -EINVAL;
+                        kfree(tx_latency);
+                        goto unlock;
+                }
+                prev_bin = tx_latency->ranges[i];
+        }
+        rcu_assign_pointer(local->tx_latency, tx_latency);
+
+unlock:
+        mutex_unlock(&local->sta_mtx);
+
+        return ret;
+}
+
+static const struct file_operations stats_tx_latency_ops = {
+        .write = sta_tx_latency_stat_write,
+        .read = sta_tx_latency_stat_read,
+        .open = simple_open,
+        .llseek = generic_file_llseek,
+};
+
 int mac80211_format_buffer(char __user *userbuf, size_t count,
                                   loff_t *ppos, char *fmt, ...)
 {
@@ -315,4 +481,6 @@ void debugfs_hw_add(struct ieee80211_local *local)
         DEBUGFS_DEVSTATS_ADD(dot11RTSFailureCount);
         DEBUGFS_DEVSTATS_ADD(dot11FCSErrorCount);
         DEBUGFS_DEVSTATS_ADD(dot11RTSSuccessCount);
+
+        DEBUGFS_DEVSTATS_ADD(tx_latency);
 }
diff --git a/net/mac80211/debugfs_sta.c b/net/mac80211/debugfs_sta.c
index 19c54a44ed47..80194b557a0c 100644
--- a/net/mac80211/debugfs_sta.c
+++ b/net/mac80211/debugfs_sta.c
@@ -38,6 +38,13 @@ static const struct file_operations sta_ ##name## _ops = {		\
         .llseek = generic_file_llseek,                                  \
 }
 
+#define STA_OPS_W(name)                                                 \
+static const struct file_operations sta_ ##name## _ops = {              \
+        .write = sta_##name##_write,                                    \
+        .open = simple_open,                                            \
+        .llseek = generic_file_llseek,                                  \
+}
+
 #define STA_OPS_RW(name)                                                \
 static const struct file_operations sta_ ##name## _ops = {              \
         .read = sta_##name##_read,                                      \
@@ -388,6 +395,131 @@ static ssize_t sta_last_rx_rate_read(struct file *file, char __user *userbuf,
 }
 STA_OPS(last_rx_rate);
 
+static int
+sta_tx_latency_stat_header(struct ieee80211_tx_latency_bin_ranges *tx_latency,
+                           char *buf, int pos, int bufsz)
+{
+        int i;
+        int range_count = tx_latency->n_ranges;
+        u32 *bin_ranges = tx_latency->ranges;
+
+        pos += scnprintf(buf + pos, bufsz - pos,
+                          "Station\t\t\tTID\tMax\tAvg");
+        if (range_count) {
+                pos += scnprintf(buf + pos, bufsz - pos,
+                                  "\t<=%d", bin_ranges[0]);
+                for (i = 0; i < range_count - 1; i++)
+                        pos += scnprintf(buf + pos, bufsz - pos, "\t%d-%d",
+                                          bin_ranges[i], bin_ranges[i+1]);
+                pos += scnprintf(buf + pos, bufsz - pos,
+                                  "\t%d<", bin_ranges[range_count - 1]);
+        }
+
+        pos += scnprintf(buf + pos, bufsz - pos, "\n");
+
+        return pos;
+}
+
+static int
+sta_tx_latency_stat_table(struct ieee80211_tx_latency_bin_ranges *tx_lat_range,
+                          struct ieee80211_tx_latency_stat *tx_lat,
+                          char *buf, int pos, int bufsz, int tid)
+{
+        u32 avg = 0;
+        int j;
+        int bin_count = tx_lat->bin_count;
+
+        pos += scnprintf(buf + pos, bufsz - pos, "\t\t\t%d", tid);
+        /* make sure you don't divide in 0 */
+        if (tx_lat->counter)
+                avg = tx_lat->sum / tx_lat->counter;
+
+        pos += scnprintf(buf + pos, bufsz - pos, "\t%d\t%d",
+                          tx_lat->max, avg);
+
+        if (tx_lat_range->n_ranges && tx_lat->bins)
+                for (j = 0; j < bin_count; j++)
+                        pos += scnprintf(buf + pos, bufsz - pos,
+                                          "\t%d", tx_lat->bins[j]);
+        pos += scnprintf(buf + pos, bufsz - pos, "\n");
+
+        return pos;
+}
+
+/*
+ * Output Tx latency statistics station && restart all statistics information
+ */
+static ssize_t sta_tx_latency_stat_read(struct file *file,
+                                        char __user *userbuf,
+                                        size_t count, loff_t *ppos)
+{
+        struct sta_info *sta = file->private_data;
+        struct ieee80211_local *local = sta->local;
+        struct ieee80211_tx_latency_bin_ranges *tx_latency;
+        char *buf;
+        int bufsz, ret, i;
+        int pos = 0;
+
+        bufsz = 20 * IEEE80211_NUM_TIDS *
+                sizeof(struct ieee80211_tx_latency_stat);
+        buf = kzalloc(bufsz, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        rcu_read_lock();
+
+        tx_latency = rcu_dereference(local->tx_latency);
+
+        if (!sta->tx_lat) {
+                pos += scnprintf(buf + pos, bufsz - pos,
+                                 "Tx latency statistics are not enabled\n");
+                goto unlock;
+        }
+
+        pos = sta_tx_latency_stat_header(tx_latency, buf, pos, bufsz);
+
+        pos += scnprintf(buf + pos, bufsz - pos, "%pM\n", sta->sta.addr);
+        for (i = 0; i < IEEE80211_NUM_TIDS; i++)
+                pos = sta_tx_latency_stat_table(tx_latency, &sta->tx_lat[i],
+                                                buf, pos, bufsz, i);
+unlock:
+        rcu_read_unlock();
+
+        ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
+        kfree(buf);
+
+        return ret;
+}
+STA_OPS(tx_latency_stat);
+
+static ssize_t sta_tx_latency_stat_reset_write(struct file *file,
+                                               const char __user *userbuf,
+                                               size_t count, loff_t *ppos)
+{
+        u32 *bins;
+        int bin_count;
+        struct sta_info *sta = file->private_data;
+        int i;
+
+        if (!sta->tx_lat)
+                return -EINVAL;
+
+        for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
+                bins = sta->tx_lat[i].bins;
+                bin_count = sta->tx_lat[i].bin_count;
+
+                sta->tx_lat[i].max = 0;
+                sta->tx_lat[i].sum = 0;
+                sta->tx_lat[i].counter = 0;
+
+                if (bin_count)
+                        memset(bins, 0, bin_count * sizeof(u32));
+        }
+
+        return count;
+}
+STA_OPS_W(tx_latency_stat_reset);
+
 #define DEBUGFS_ADD(name) \
         debugfs_create_file(#name, 0400, \
                 sta->debugfs.dir, sta, &sta_ ##name## _ops);
@@ -441,6 +573,8 @@ void ieee80211_sta_debugfs_add(struct sta_info *sta)
         DEBUGFS_ADD(last_ack_signal);
         DEBUGFS_ADD(current_tx_rate);
         DEBUGFS_ADD(last_rx_rate);
+        DEBUGFS_ADD(tx_latency_stat);
+        DEBUGFS_ADD(tx_latency_stat_reset);
 
         DEBUGFS_ADD_COUNTER(rx_packets, rx_packets);
         DEBUGFS_ADD_COUNTER(tx_packets, tx_packets);
diff --git a/net/mac80211/ibss.c b/net/mac80211/ibss.c
index 27a39de89679..2eda7b13124a 100644
--- a/net/mac80211/ibss.c
+++ b/net/mac80211/ibss.c
@@ -550,12 +550,12 @@ int ieee80211_ibss_finish_csa(struct ieee80211_sub_if_data *sdata)
                                         capability);
                 /* XXX: should not really modify cfg80211 data */
                 if (cbss) {
-                        cbss->channel = sdata->local->csa_chandef.chan;
+                        cbss->channel = sdata->csa_chandef.chan;
                         cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
                 }
         }
 
-        ifibss->chandef = sdata->local->csa_chandef;
+        ifibss->chandef = sdata->csa_chandef;
 
         /* generate the beacon */
         err = ieee80211_ibss_csa_beacon(sdata, NULL);
@@ -926,7 +926,7 @@ ieee80211_ibss_process_chanswitch(struct ieee80211_sub_if_data *sdata,
                                 IEEE80211_MAX_QUEUE_MAP,
                                 IEEE80211_QUEUE_STOP_REASON_CSA);
 
-        sdata->local->csa_chandef = params.chandef;
+        sdata->csa_chandef = params.chandef;
         sdata->vif.csa_active = true;
 
         ieee80211_bss_info_change_notify(sdata, err);
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index 4aea4e791113..ed5bf8b4b5c2 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -728,6 +728,7 @@ struct ieee80211_sub_if_data {
         u16 sequence_number;
         __be16 control_port_protocol;
         bool control_port_no_encrypt;
+        int encrypt_headroom;
 
         struct ieee80211_tx_queue_params tx_conf[IEEE80211_NUM_ACS];
 
@@ -735,6 +736,7 @@ struct ieee80211_sub_if_data {
         int csa_counter_offset_beacon;
         int csa_counter_offset_presp;
         bool csa_radar_required;
+        struct cfg80211_chan_def csa_chandef;
 
         /* used to reconfigure hardware SM PS */
         struct work_struct recalc_smps;
@@ -811,6 +813,9 @@ static inline void sdata_unlock(struct ieee80211_sub_if_data *sdata)
         __release(&sdata->wdev.mtx);
 }
 
+#define sdata_dereference(p, sdata) \
+        rcu_dereference_protected(p, lockdep_is_held(&sdata->wdev.mtx))
+
 static inline void
 sdata_assert_lock(struct ieee80211_sub_if_data *sdata)
 {
@@ -896,6 +901,24 @@ struct tpt_led_trigger {
 };
 #endif
 
+/*
+ * struct ieee80211_tx_latency_bin_ranges - Tx latency statistics bins ranges
+ *
+ * Measuring Tx latency statistics. Counts how many Tx frames transmitted in a
+ * certain latency range (in Milliseconds). Each station that uses these
+ * ranges will have bins to count the amount of frames received in that range.
+ * The user can configure the ranges via debugfs.
+ * If ranges is NULL then Tx latency statistics bins are disabled for all
+ * stations.
+ *
+ * @n_ranges: number of ranges that are taken in account
+ * @ranges: the ranges that the user requested or NULL if disabled.
+ */
+struct ieee80211_tx_latency_bin_ranges {
+        int n_ranges;
+        u32 ranges[];
+};
+
 /**
  * mac80211 scan flags - currently active scan mode
  *
@@ -1048,6 +1071,12 @@ struct ieee80211_local {
         struct timer_list sta_cleanup;
         int sta_generation;
 
+        /*
+         * Tx latency statistics parameters for all stations.
+         * Can enable via debugfs (NULL when disabled).
+         */
+        struct ieee80211_tx_latency_bin_ranges __rcu *tx_latency;
+
         struct sk_buff_head pending[IEEE80211_MAX_QUEUES];
         struct tasklet_struct tx_pending_tasklet;
 
@@ -1093,7 +1122,6 @@ struct ieee80211_local {
         enum mac80211_scan_state next_scan_state;
         struct delayed_work scan_work;
         struct ieee80211_sub_if_data __rcu *scan_sdata;
-        struct cfg80211_chan_def csa_chandef;
         /* For backward compatibility only -- do not use */
         struct cfg80211_chan_def _oper_chandef;
 
@@ -1693,6 +1721,7 @@ int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
 int __ieee80211_request_smps_ap(struct ieee80211_sub_if_data *sdata,
                                 enum ieee80211_smps_mode smps_mode);
 void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata);
+void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata);
 
 size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
                           const u8 *ids, int n_ids, size_t offset);
@@ -1731,7 +1760,6 @@ ieee80211_vif_change_bandwidth(struct ieee80211_sub_if_data *sdata,
 /* NOTE: only use ieee80211_vif_change_channel() for channel switch */
 int __must_check
 ieee80211_vif_change_channel(struct ieee80211_sub_if_data *sdata,
-                             const struct cfg80211_chan_def *chandef,
                              u32 *changed);
 void ieee80211_vif_release_channel(struct ieee80211_sub_if_data *sdata);
 void ieee80211_vif_vlan_copy_chanctx(struct ieee80211_sub_if_data *sdata);
@@ -1742,6 +1770,8 @@ void ieee80211_recalc_smps_chanctx(struct ieee80211_local *local,
                                    struct ieee80211_chanctx *chanctx);
 void ieee80211_recalc_radar_chanctx(struct ieee80211_local *local,
                                     struct ieee80211_chanctx *chanctx);
+void ieee80211_recalc_chanctx_min_def(struct ieee80211_local *local,
+                                      struct ieee80211_chanctx *ctx);
 
 void ieee80211_dfs_cac_timer(unsigned long data);
 void ieee80211_dfs_cac_timer_work(struct work_struct *work);
@@ -1750,6 +1780,15 @@ void ieee80211_dfs_radar_detected_work(struct work_struct *work);
 int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
                               struct cfg80211_csa_settings *csa_settings);
 
+bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs);
+bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n);
+const struct ieee80211_cipher_scheme *
+ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
+                 enum nl80211_iftype iftype);
+int ieee80211_cs_headroom(struct ieee80211_local *local,
+                          struct cfg80211_crypto_settings *crypto,
+                          enum nl80211_iftype iftype);
+
 #ifdef CONFIG_MAC80211_NOINLINE
 #define debug_noinline noinline
 #else
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index 36c3a4cbcabf..7aa9f9dea9df 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -401,6 +401,8 @@ int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
         snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
                  wiphy_name(local->hw.wiphy));
 
+        sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
+
         ieee80211_set_default_queues(sdata);
 
         ret = drv_add_interface(local, sdata);
@@ -749,6 +751,7 @@ static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
         u32 hw_reconf_flags = 0;
         int i, flushed;
         struct ps_data *ps;
+        struct cfg80211_chan_def chandef;
 
         clear_bit(SDATA_STATE_RUNNING, &sdata->state);
 
@@ -823,11 +826,13 @@ static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
         cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
 
         if (sdata->wdev.cac_started) {
+                chandef = sdata->vif.bss_conf.chandef;
                 WARN_ON(local->suspended);
                 mutex_lock(&local->iflist_mtx);
                 ieee80211_vif_release_channel(sdata);
                 mutex_unlock(&local->iflist_mtx);
-                cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_ABORTED,
+                cfg80211_cac_event(sdata->dev, &chandef,
+                                   NL80211_RADAR_CAC_ABORTED,
                                    GFP_KERNEL);
         }
 
@@ -1036,7 +1041,6 @@ static void ieee80211_set_multicast_list(struct net_device *dev)
  */
 static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
 {
-        int flushed;
         int i;
 
         /* free extra data */
@@ -1050,9 +1054,6 @@ static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
 
         if (ieee80211_vif_is_mesh(&sdata->vif))
                 mesh_rmc_free(sdata);
-
-        flushed = sta_info_flush(sdata);
-        WARN_ON(flushed);
 }
 
 static void ieee80211_uninit(struct net_device *dev)
@@ -1270,6 +1271,7 @@ static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
 
         sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
         sdata->control_port_no_encrypt = false;
+        sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
 
         sdata->noack_map = 0;
 
@@ -1685,6 +1687,8 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
         sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
         sdata->user_power_level = local->user_power_level;
 
+        sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
+
         /* setup type-dependent data */
         ieee80211_setup_sdata(sdata, type);
 
diff --git a/net/mac80211/key.c b/net/mac80211/key.c
index 3e51dd7d98b3..e568d98167d0 100644
--- a/net/mac80211/key.c
+++ b/net/mac80211/key.c
@@ -260,25 +260,29 @@ static void ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
         int idx;
         bool defunikey, defmultikey, defmgmtkey;
 
+        /* caller must provide at least one old/new */
+        if (WARN_ON(!new && !old))
+                return;
+
         if (new)
                 list_add_tail(&new->list, &sdata->key_list);
 
-        if (sta && pairwise) {
-                rcu_assign_pointer(sta->ptk, new);
-        } else if (sta) {
-                if (old)
-                        idx = old->conf.keyidx;
-                else
-                        idx = new->conf.keyidx;
-                rcu_assign_pointer(sta->gtk[idx], new);
-        } else {
-                WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
+        WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
 
-                if (old)
-                        idx = old->conf.keyidx;
-                else
-                        idx = new->conf.keyidx;
+        if (old)
+                idx = old->conf.keyidx;
+        else
+                idx = new->conf.keyidx;
 
+        if (sta) {
+                if (pairwise) {
+                        rcu_assign_pointer(sta->ptk[idx], new);
+                        sta->ptk_idx = idx;
+                } else {
+                        rcu_assign_pointer(sta->gtk[idx], new);
+                        sta->gtk_idx = idx;
+                }
+        } else {
                 defunikey = old &&
                         old == key_mtx_dereference(sdata->local,
                                                 sdata->default_unicast_key);
@@ -312,9 +316,11 @@ static void ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
                 list_del(&old->list);
 }
 
-struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
-                                          const u8 *key_data,
-                                          size_t seq_len, const u8 *seq)
+struct ieee80211_key *
+ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
+                    const u8 *key_data,
+                    size_t seq_len, const u8 *seq,
+                    const struct ieee80211_cipher_scheme *cs)
 {
         struct ieee80211_key *key;
         int i, j, err;
@@ -393,6 +399,18 @@ struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
                         return ERR_PTR(err);
                 }
                 break;
+        default:
+                if (cs) {
+                        size_t len = (seq_len > MAX_PN_LEN) ?
+                                                MAX_PN_LEN : seq_len;
+
+                        key->conf.iv_len = cs->hdr_len;
+                        key->conf.icv_len = cs->mic_len;
+                        for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++)
+                                for (j = 0; j < len; j++)
+                                        key->u.gen.rx_pn[i][j] =
+                                                        seq[len - j - 1];
+                }
         }
         memcpy(key->conf.key, key_data, key_len);
         INIT_LIST_HEAD(&key->list);
@@ -475,7 +493,7 @@ int ieee80211_key_link(struct ieee80211_key *key,
         mutex_lock(&sdata->local->key_mtx);
 
         if (sta && pairwise)
-                old_key = key_mtx_dereference(sdata->local, sta->ptk);
+                old_key = key_mtx_dereference(sdata->local, sta->ptk[idx]);
         else if (sta)
                 old_key = key_mtx_dereference(sdata->local, sta->gtk[idx]);
         else
@@ -625,8 +643,10 @@ void ieee80211_free_sta_keys(struct ieee80211_local *local,
                 list_add(&key->list, &keys);
         }
 
-        key = key_mtx_dereference(local, sta->ptk);
-        if (key) {
+        for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
+                key = key_mtx_dereference(local, sta->ptk[i]);
+                if (!key)
+                        continue;
                 ieee80211_key_replace(key->sdata, key->sta,
                                 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
                                 key, NULL);
@@ -877,7 +897,7 @@ ieee80211_gtk_rekey_add(struct ieee80211_vif *vif,
 
         key = ieee80211_key_alloc(keyconf->cipher, keyconf->keyidx,
                                   keyconf->keylen, keyconf->key,
-                                  0, NULL);
+                                  0, NULL, NULL);
         if (IS_ERR(key))
                 return ERR_CAST(key);
 
diff --git a/net/mac80211/key.h b/net/mac80211/key.h
index aaae0ed37004..0aebb889caba 100644
--- a/net/mac80211/key.h
+++ b/net/mac80211/key.h
@@ -18,6 +18,7 @@
 
 #define NUM_DEFAULT_KEYS 4
 #define NUM_DEFAULT_MGMT_KEYS 2
+#define MAX_PN_LEN 16
 
 struct ieee80211_local;
 struct ieee80211_sub_if_data;
@@ -93,6 +94,10 @@ struct ieee80211_key {
                         u32 replays; /* dot11RSNAStatsCMACReplays */
                         u32 icverrors; /* dot11RSNAStatsCMACICVErrors */
                 } aes_cmac;
+                struct {
+                        /* generic cipher scheme */
+                        u8 rx_pn[IEEE80211_NUM_TIDS + 1][MAX_PN_LEN];
+                } gen;
         } u;
 
         /* number of times this key has been used */
@@ -113,9 +118,11 @@ struct ieee80211_key {
         struct ieee80211_key_conf conf;
 };
 
-struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
-                                          const u8 *key_data,
-                                          size_t seq_len, const u8 *seq);
+struct ieee80211_key *
+ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
+                    const u8 *key_data,
+                    size_t seq_len, const u8 *seq,
+                    const struct ieee80211_cipher_scheme *cs);
 /*
  * Insert a key into data structures (sdata, sta if necessary)
  * to make it used, free old key. On failure, also free the new key.
diff --git a/net/mac80211/main.c b/net/mac80211/main.c
index 7d1c3ac48ed9..fa34cd2344b9 100644
--- a/net/mac80211/main.c
+++ b/net/mac80211/main.c
@@ -651,15 +651,14 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
 }
 EXPORT_SYMBOL(ieee80211_alloc_hw);
 
-int ieee80211_register_hw(struct ieee80211_hw *hw)
+static int ieee80211_init_cipher_suites(struct ieee80211_local *local)
 {
-        struct ieee80211_local *local = hw_to_local(hw);
-        int result, i;
-        enum ieee80211_band band;
-        int channels, max_bitrates;
-        bool supp_ht, supp_vht;
-        netdev_features_t feature_whitelist;
-        struct cfg80211_chan_def dflt_chandef = {};
+        bool have_wep = !(IS_ERR(local->wep_tx_tfm) ||
+                          IS_ERR(local->wep_rx_tfm));
+        bool have_mfp = local->hw.flags & IEEE80211_HW_MFP_CAPABLE;
+        const struct ieee80211_cipher_scheme *cs = local->hw.cipher_schemes;
+        int n_suites = 0, r = 0, w = 0;
+        u32 *suites;
         static const u32 cipher_suites[] = {
                 /* keep WEP first, it may be removed below */
                 WLAN_CIPHER_SUITE_WEP40,
@@ -671,6 +670,93 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
                 WLAN_CIPHER_SUITE_AES_CMAC
         };
 
+        /* Driver specifies the ciphers, we have nothing to do... */
+        if (local->hw.wiphy->cipher_suites && have_wep)
+                return 0;
+
+        /* Set up cipher suites if driver relies on mac80211 cipher defs */
+        if (!local->hw.wiphy->cipher_suites && !cs) {
+                local->hw.wiphy->cipher_suites = cipher_suites;
+                local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
+
+                if (!have_mfp)
+                        local->hw.wiphy->n_cipher_suites--;
+
+                if (!have_wep) {
+                        local->hw.wiphy->cipher_suites += 2;
+                        local->hw.wiphy->n_cipher_suites -= 2;
+                }
+
+                return 0;
+        }
+
+        if (!local->hw.wiphy->cipher_suites) {
+                /*
+                 * Driver specifies cipher schemes only
+                 * We start counting ciphers defined by schemes, TKIP and CCMP
+                 */
+                n_suites = local->hw.n_cipher_schemes + 2;
+
+                /* check if we have WEP40 and WEP104 */
+                if (have_wep)
+                        n_suites += 2;
+
+                /* check if we have AES_CMAC */
+                if (have_mfp)
+                        n_suites++;
+
+                suites = kmalloc(sizeof(u32) * n_suites, GFP_KERNEL);
+                if (!suites)
+                        return -ENOMEM;
+
+                suites[w++] = WLAN_CIPHER_SUITE_CCMP;
+                suites[w++] = WLAN_CIPHER_SUITE_TKIP;
+
+                if (have_wep) {
+                        suites[w++] = WLAN_CIPHER_SUITE_WEP40;
+                        suites[w++] = WLAN_CIPHER_SUITE_WEP104;
+                }
+
+                if (have_mfp)
+                        suites[w++] = WLAN_CIPHER_SUITE_AES_CMAC;
+
+                for (r = 0; r < local->hw.n_cipher_schemes; r++)
+                        suites[w++] = cs[r].cipher;
+        } else {
+                /* Driver provides cipher suites, but we need to exclude WEP */
+                suites = kmemdup(local->hw.wiphy->cipher_suites,
+                                 sizeof(u32) * local->hw.wiphy->n_cipher_suites,
+                                 GFP_KERNEL);
+                if (!suites)
+                        return -ENOMEM;
+
+                for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) {
+                        u32 suite = local->hw.wiphy->cipher_suites[r];
+
+                        if (suite == WLAN_CIPHER_SUITE_WEP40 ||
+                            suite == WLAN_CIPHER_SUITE_WEP104)
+                                continue;
+                        suites[w++] = suite;
+                }
+        }
+
+        local->hw.wiphy->cipher_suites = suites;
+        local->hw.wiphy->n_cipher_suites = w;
+        local->wiphy_ciphers_allocated = true;
+
+        return 0;
+}
+
+int ieee80211_register_hw(struct ieee80211_hw *hw)
+{
+        struct ieee80211_local *local = hw_to_local(hw);
+        int result, i;
+        enum ieee80211_band band;
+        int channels, max_bitrates;
+        bool supp_ht, supp_vht;
+        netdev_features_t feature_whitelist;
+        struct cfg80211_chan_def dflt_chandef = {};
+
         if (hw->flags & IEEE80211_HW_QUEUE_CONTROL &&
             (local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE ||
              local->hw.offchannel_tx_hw_queue >= local->hw.queues))
@@ -851,43 +937,12 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
         if (local->hw.wiphy->max_scan_ie_len)
                 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len;
 
-        /* Set up cipher suites unless driver already did */
-        if (!local->hw.wiphy->cipher_suites) {
-                local->hw.wiphy->cipher_suites = cipher_suites;
-                local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
-                if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE))
-                        local->hw.wiphy->n_cipher_suites--;
-        }
-        if (IS_ERR(local->wep_tx_tfm) || IS_ERR(local->wep_rx_tfm)) {
-                if (local->hw.wiphy->cipher_suites == cipher_suites) {
-                        local->hw.wiphy->cipher_suites += 2;
-                        local->hw.wiphy->n_cipher_suites -= 2;
-                } else {
-                        u32 *suites;
-                        int r, w = 0;
-
-                        /* Filter out WEP */
-
-                        suites = kmemdup(
-                                local->hw.wiphy->cipher_suites,
-                                sizeof(u32) * local->hw.wiphy->n_cipher_suites,
-                                GFP_KERNEL);
-                        if (!suites) {
-                                result = -ENOMEM;
-                                goto fail_wiphy_register;
-                        }
-                        for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) {
-                                u32 suite = local->hw.wiphy->cipher_suites[r];
-                                if (suite == WLAN_CIPHER_SUITE_WEP40 ||
-                                    suite == WLAN_CIPHER_SUITE_WEP104)
-                                        continue;
-                                suites[w++] = suite;
-                        }
-                        local->hw.wiphy->cipher_suites = suites;
-                        local->hw.wiphy->n_cipher_suites = w;
-                        local->wiphy_ciphers_allocated = true;
-                }
-        }
+        WARN_ON(!ieee80211_cs_list_valid(local->hw.cipher_schemes,
+                                         local->hw.n_cipher_schemes));
+
+        result = ieee80211_init_cipher_suites(local);
+        if (result < 0)
+                goto fail_wiphy_register;
 
         if (!local->ops->remain_on_channel)
                 local->hw.wiphy->max_remain_on_channel_duration = 5000;
@@ -1090,6 +1145,8 @@ void ieee80211_free_hw(struct ieee80211_hw *hw)
                      ieee80211_free_ack_frame, NULL);
         idr_destroy(&local->ack_status_frames);
 
+        kfree(rcu_access_pointer(local->tx_latency));
+
         wiphy_free(local->hw.wiphy);
 }
 EXPORT_SYMBOL(ieee80211_free_hw);
diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index ba105257d03f..89df62b2b689 100644
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -674,8 +674,6 @@ ieee80211_mesh_build_beacon(struct ieee80211_if_mesh *ifmsh)
         rcu_read_lock();
         csa = rcu_dereference(ifmsh->csa);
         if (csa) {
-                __le16 pre_value;
-
                 pos = skb_put(skb, 13);
                 memset(pos, 0, 13);
                 *pos++ = WLAN_EID_CHANNEL_SWITCH;
@@ -697,8 +695,7 @@ ieee80211_mesh_build_beacon(struct ieee80211_if_mesh *ifmsh)
                           WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
                 put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos);
                 pos += 2;
-                pre_value = cpu_to_le16(ifmsh->pre_value);
-                memcpy(pos, &pre_value, 2);
+                put_unaligned_le16(ifmsh->pre_value, pos);
                 pos += 2;
         }
         rcu_read_unlock();
@@ -964,7 +961,7 @@ ieee80211_mesh_process_chnswitch(struct ieee80211_sub_if_data *sdata,
                                 IEEE80211_MAX_QUEUE_MAP,
                                 IEEE80211_QUEUE_STOP_REASON_CSA);
 
-        sdata->local->csa_chandef = params.chandef;
+        sdata->csa_chandef = params.chandef;
         sdata->vif.csa_active = true;
 
         ieee80211_bss_info_change_notify(sdata, err);
diff --git a/net/mac80211/mesh.h b/net/mac80211/mesh.h
index 2bc7fd2f787d..f39a19f9090f 100644
--- a/net/mac80211/mesh.h
+++ b/net/mac80211/mesh.h
@@ -215,8 +215,6 @@ int mesh_rmc_check(struct ieee80211_sub_if_data *sdata,
 bool mesh_matches_local(struct ieee80211_sub_if_data *sdata,
                         struct ieee802_11_elems *ie);
 void mesh_ids_set_default(struct ieee80211_if_mesh *mesh);
-void mesh_mgmt_ies_add(struct ieee80211_sub_if_data *sdata,
-                       struct sk_buff *skb);
 int mesh_add_meshconf_ie(struct ieee80211_sub_if_data *sdata,
                          struct sk_buff *skb);
 int mesh_add_meshid_ie(struct ieee80211_sub_if_data *sdata,
@@ -303,8 +301,8 @@ void mesh_mpath_table_grow(void);
 void mesh_mpp_table_grow(void);
 /* Mesh paths */
 int mesh_path_error_tx(struct ieee80211_sub_if_data *sdata,
-                       u8 ttl, const u8 *target, __le32 target_sn,
-                       __le16 target_rcode, const u8 *ra);
+                       u8 ttl, const u8 *target, u32 target_sn,
+                       u16 target_rcode, const u8 *ra);
 void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta);
 void mesh_path_flush_pending(struct mesh_path *mpath);
 void mesh_path_tx_pending(struct mesh_path *mpath);
diff --git a/net/mac80211/mesh_hwmp.c b/net/mac80211/mesh_hwmp.c
index 486819cd02cd..f9514685d45a 100644
--- a/net/mac80211/mesh_hwmp.c
+++ b/net/mac80211/mesh_hwmp.c
@@ -102,12 +102,11 @@ enum mpath_frame_type {
 static const u8 broadcast_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
 static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
-                                  const u8 *orig_addr, __le32 orig_sn,
+                                  const u8 *orig_addr, u32 orig_sn,
                                   u8 target_flags, const u8 *target,
-                                  __le32 target_sn, const u8 *da,
+                                  u32 target_sn, const u8 *da,
                                   u8 hop_count, u8 ttl,
-                                  __le32 lifetime, __le32 metric,
-                                  __le32 preq_id,
+                                  u32 lifetime, u32 metric, u32 preq_id,
                                   struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_local *local = sdata->local;
@@ -167,33 +166,33 @@ static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
         if (action == MPATH_PREP) {
                 memcpy(pos, target, ETH_ALEN);
                 pos += ETH_ALEN;
-                memcpy(pos, &target_sn, 4);
+                put_unaligned_le32(target_sn, pos);
                 pos += 4;
         } else {
                 if (action == MPATH_PREQ) {
-                        memcpy(pos, &preq_id, 4);
+                        put_unaligned_le32(preq_id, pos);
                         pos += 4;
                 }
                 memcpy(pos, orig_addr, ETH_ALEN);
                 pos += ETH_ALEN;
-                memcpy(pos, &orig_sn, 4);
+                put_unaligned_le32(orig_sn, pos);
                 pos += 4;
         }
-        memcpy(pos, &lifetime, 4);      /* interval for RANN */
+        put_unaligned_le32(lifetime, pos); /* interval for RANN */
         pos += 4;
-        memcpy(pos, &metric, 4);
+        put_unaligned_le32(metric, pos);
         pos += 4;
         if (action == MPATH_PREQ) {
                 *pos++ = 1; /* destination count */
                 *pos++ = target_flags;
                 memcpy(pos, target, ETH_ALEN);
                 pos += ETH_ALEN;
-                memcpy(pos, &target_sn, 4);
+                put_unaligned_le32(target_sn, pos);
                 pos += 4;
         } else if (action == MPATH_PREP) {
                 memcpy(pos, orig_addr, ETH_ALEN);
                 pos += ETH_ALEN;
-                memcpy(pos, &orig_sn, 4);
+                put_unaligned_le32(orig_sn, pos);
                 pos += 4;
         }
 
@@ -239,8 +238,8 @@ static void prepare_frame_for_deferred_tx(struct ieee80211_sub_if_data *sdata,
  * frame directly but add it to the pending queue instead.
  */
 int mesh_path_error_tx(struct ieee80211_sub_if_data *sdata,
-                       u8 ttl, const u8 *target, __le32 target_sn,
-                       __le16 target_rcode, const u8 *ra)
+                       u8 ttl, const u8 *target, u32 target_sn,
+                       u16 target_rcode, const u8 *ra)
 {
         struct ieee80211_local *local = sdata->local;
         struct sk_buff *skb;
@@ -254,13 +253,13 @@ int mesh_path_error_tx(struct ieee80211_sub_if_data *sdata,
                 return -EAGAIN;
 
         skb = dev_alloc_skb(local->tx_headroom +
-                            IEEE80211_ENCRYPT_HEADROOM +
+                            sdata->encrypt_headroom +
                             IEEE80211_ENCRYPT_TAILROOM +
                             hdr_len +
                             2 + 15 /* PERR IE */);
         if (!skb)
                 return -1;
-        skb_reserve(skb, local->tx_headroom + IEEE80211_ENCRYPT_HEADROOM);
+        skb_reserve(skb, local->tx_headroom + sdata->encrypt_headroom);
         mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
         memset(mgmt, 0, hdr_len);
         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
@@ -293,9 +292,9 @@ int mesh_path_error_tx(struct ieee80211_sub_if_data *sdata,
         pos++;
         memcpy(pos, target, ETH_ALEN);
         pos += ETH_ALEN;
-        memcpy(pos, &target_sn, 4);
+        put_unaligned_le32(target_sn, pos);
         pos += 4;
-        memcpy(pos, &target_rcode, 2);
+        put_unaligned_le16(target_rcode, pos);
 
         /* see note in function header */
         prepare_frame_for_deferred_tx(sdata, skb);
@@ -592,10 +591,9 @@ static void hwmp_preq_frame_process(struct ieee80211_sub_if_data *sdata,
                 if (ttl != 0) {
                         mhwmp_dbg(sdata, "replying to the PREQ\n");
                         mesh_path_sel_frame_tx(MPATH_PREP, 0, orig_addr,
-                                cpu_to_le32(orig_sn), 0, target_addr,
-                                cpu_to_le32(target_sn), mgmt->sa, 0, ttl,
-                                cpu_to_le32(lifetime), cpu_to_le32(metric),
-                                0, sdata);
+                                               orig_sn, 0, target_addr,
+                                               target_sn, mgmt->sa, 0, ttl,
+                                               lifetime, metric, 0, sdata);
                 } else {
                         ifmsh->mshstats.dropped_frames_ttl++;
                 }
@@ -625,11 +623,9 @@ static void hwmp_preq_frame_process(struct ieee80211_sub_if_data *sdata,
                 }
 
                 mesh_path_sel_frame_tx(MPATH_PREQ, flags, orig_addr,
-                                cpu_to_le32(orig_sn), target_flags, target_addr,
-                                cpu_to_le32(target_sn), da,
-                                hopcount, ttl, cpu_to_le32(lifetime),
-                                cpu_to_le32(metric), cpu_to_le32(preq_id),
-                                sdata);
+                                       orig_sn, target_flags, target_addr,
+                                       target_sn, da, hopcount, ttl, lifetime,
+                                       metric, preq_id, sdata);
                 if (!is_multicast_ether_addr(da))
                         ifmsh->mshstats.fwded_unicast++;
                 else
@@ -695,11 +691,9 @@ static void hwmp_prep_frame_process(struct ieee80211_sub_if_data *sdata,
         target_sn = PREP_IE_TARGET_SN(prep_elem);
         orig_sn = PREP_IE_ORIG_SN(prep_elem);
 
-        mesh_path_sel_frame_tx(MPATH_PREP, flags, orig_addr,
-                cpu_to_le32(orig_sn), 0, target_addr,
-                cpu_to_le32(target_sn), next_hop, hopcount,
-                ttl, cpu_to_le32(lifetime), cpu_to_le32(metric),
-                0, sdata);
+        mesh_path_sel_frame_tx(MPATH_PREP, flags, orig_addr, orig_sn, 0,
+                               target_addr, target_sn, next_hop, hopcount,
+                               ttl, lifetime, metric, 0, sdata);
         rcu_read_unlock();
 
         sdata->u.mesh.mshstats.fwded_unicast++;
@@ -750,8 +744,7 @@ static void hwmp_perr_frame_process(struct ieee80211_sub_if_data *sdata,
                         if (!ifmsh->mshcfg.dot11MeshForwarding)
                                 goto endperr;
                         mesh_path_error_tx(sdata, ttl, target_addr,
-                                           cpu_to_le32(target_sn),
-                                           cpu_to_le16(target_rcode),
+                                           target_sn, target_rcode,
                                            broadcast_addr);
                 } else
                         spin_unlock_bh(&mpath->state_lock);
@@ -847,11 +840,9 @@ static void hwmp_rann_frame_process(struct ieee80211_sub_if_data *sdata,
 
         if (ifmsh->mshcfg.dot11MeshForwarding) {
                 mesh_path_sel_frame_tx(MPATH_RANN, flags, orig_addr,
-                                       cpu_to_le32(orig_sn),
-                                       0, NULL, 0, broadcast_addr,
-                                       hopcount, ttl, cpu_to_le32(interval),
-                                       cpu_to_le32(metric + metric_txsta),
-                                       0, sdata);
+                                       orig_sn, 0, NULL, 0, broadcast_addr,
+                                       hopcount, ttl, interval,
+                                       metric + metric_txsta, 0, sdata);
         }
 
         rcu_read_unlock();
@@ -1049,11 +1040,9 @@ void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata)
 
         spin_unlock_bh(&mpath->state_lock);
         da = (mpath->is_root) ? mpath->rann_snd_addr : broadcast_addr;
-        mesh_path_sel_frame_tx(MPATH_PREQ, 0, sdata->vif.addr,
-                        cpu_to_le32(ifmsh->sn), target_flags, mpath->dst,
-                        cpu_to_le32(mpath->sn), da, 0,
-                        ttl, cpu_to_le32(lifetime), 0,
-                        cpu_to_le32(ifmsh->preq_id++), sdata);
+        mesh_path_sel_frame_tx(MPATH_PREQ, 0, sdata->vif.addr, ifmsh->sn,
+                               target_flags, mpath->dst, mpath->sn, da, 0,
+                               ttl, lifetime, 0, ifmsh->preq_id++, sdata);
         mod_timer(&mpath->timer, jiffies + mpath->discovery_timeout);
 
 enddiscovery:
@@ -1212,10 +1201,9 @@ void mesh_path_tx_root_frame(struct ieee80211_sub_if_data *sdata)
         switch (ifmsh->mshcfg.dot11MeshHWMPRootMode) {
         case IEEE80211_PROACTIVE_RANN:
                 mesh_path_sel_frame_tx(MPATH_RANN, flags, sdata->vif.addr,
-                               cpu_to_le32(++ifmsh->sn),
-                               0, NULL, 0, broadcast_addr,
-                               0, ifmsh->mshcfg.element_ttl,
-                               cpu_to_le32(interval), 0, 0, sdata);
+                                       ++ifmsh->sn, 0, NULL, 0, broadcast_addr,
+                                       0, ifmsh->mshcfg.element_ttl,
+                                       interval, 0, 0, sdata);
                 break;
         case IEEE80211_PROACTIVE_PREQ_WITH_PREP:
                 flags |= IEEE80211_PREQ_PROACTIVE_PREP_FLAG;
@@ -1224,11 +1212,10 @@ void mesh_path_tx_root_frame(struct ieee80211_sub_if_data *sdata)
                 target_flags |= IEEE80211_PREQ_TO_FLAG |
                                 IEEE80211_PREQ_USN_FLAG;
                 mesh_path_sel_frame_tx(MPATH_PREQ, flags, sdata->vif.addr,
-                                cpu_to_le32(++ifmsh->sn), target_flags,
-                                (u8 *) broadcast_addr, 0, broadcast_addr,
-                                0, ifmsh->mshcfg.element_ttl,
-                                cpu_to_le32(interval),
-                                0, cpu_to_le32(ifmsh->preq_id++), sdata);
+                                       ++ifmsh->sn, target_flags,
+                                       (u8 *) broadcast_addr, 0, broadcast_addr,
+                                       0, ifmsh->mshcfg.element_ttl, interval,
+                                       0, ifmsh->preq_id++, sdata);
                 break;
         default:
                 mhwmp_dbg(sdata, "Proactive mechanism not supported\n");
diff --git a/net/mac80211/mesh_pathtbl.c b/net/mac80211/mesh_pathtbl.c
index 89aacfd2756d..7d050ed6fe5a 100644
--- a/net/mac80211/mesh_pathtbl.c
+++ b/net/mac80211/mesh_pathtbl.c
@@ -722,7 +722,6 @@ void mesh_plink_broken(struct sta_info *sta)
         struct mpath_node *node;
         struct ieee80211_sub_if_data *sdata = sta->sdata;
         int i;
-        __le16 reason = cpu_to_le16(WLAN_REASON_MESH_PATH_DEST_UNREACHABLE);
 
         rcu_read_lock();
         tbl = rcu_dereference(mesh_paths);
@@ -736,9 +735,9 @@ void mesh_plink_broken(struct sta_info *sta)
                         ++mpath->sn;
                         spin_unlock_bh(&mpath->state_lock);
                         mesh_path_error_tx(sdata,
-                                           sdata->u.mesh.mshcfg.element_ttl,
-                                           mpath->dst, cpu_to_le32(mpath->sn),
-                                           reason, bcast);
+                                sdata->u.mesh.mshcfg.element_ttl,
+                                mpath->dst, mpath->sn,
+                                WLAN_REASON_MESH_PATH_DEST_UNREACHABLE, bcast);
                 }
         }
         rcu_read_unlock();
diff --git a/net/mac80211/mesh_plink.c b/net/mac80211/mesh_plink.c
index 4301aa5aa227..cf83217103f9 100644
--- a/net/mac80211/mesh_plink.c
+++ b/net/mac80211/mesh_plink.c
@@ -19,12 +19,6 @@
 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
                                 jiffies + HZ * t / 1000))
 
-/* We only need a valid sta if user configured a minimum rssi_threshold. */
-#define rssi_threshold_check(sta, sdata) \
-                (sdata->u.mesh.mshcfg.rssi_threshold == 0 ||\
-                (sta && (s8) -ewma_read(&sta->avg_signal) > \
-                sdata->u.mesh.mshcfg.rssi_threshold))
-
 enum plink_event {
         PLINK_UNDEFINED,
         OPN_ACPT,
@@ -61,7 +55,17 @@ static const char * const mplevents[] = {
 
 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
                                enum ieee80211_self_protected_actioncode action,
-                               u8 *da, __le16 llid, __le16 plid, __le16 reason);
+                               u8 *da, u16 llid, u16 plid, u16 reason);
+
+
+/* We only need a valid sta if user configured a minimum rssi_threshold. */
+static bool rssi_threshold_check(struct ieee80211_sub_if_data *sdata,
+                                 struct sta_info *sta)
+{
+        s32 rssi_threshold = sdata->u.mesh.mshcfg.rssi_threshold;
+        return rssi_threshold == 0 ||
+               (sta && (s8) -ewma_read(&sta->avg_signal) > rssi_threshold);
+}
 
 /**
  * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
@@ -242,7 +246,7 @@ u32 mesh_plink_deactivate(struct sta_info *sta)
 
         spin_lock_bh(&sta->lock);
         changed = __mesh_plink_deactivate(sta);
-        sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED);
+        sta->reason = WLAN_REASON_MESH_PEER_CANCELED;
         mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
                             sta->sta.addr, sta->llid, sta->plid,
                             sta->reason);
@@ -253,7 +257,7 @@ u32 mesh_plink_deactivate(struct sta_info *sta)
 
 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
                                enum ieee80211_self_protected_actioncode action,
-                               u8 *da, __le16 llid, __le16 plid, __le16 reason)
+                               u8 *da, u16 llid, u16 plid, u16 reason)
 {
         struct ieee80211_local *local = sdata->local;
         struct sk_buff *skb;
@@ -279,7 +283,7 @@ static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
                             2 + 8 + /* peering IE */
                             sdata->u.mesh.ie_len);
         if (!skb)
-                return -1;
+                return err;
         info = IEEE80211_SKB_CB(skb);
         skb_reserve(skb, local->tx_headroom);
         mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
@@ -301,7 +305,7 @@ static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
                 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
                         /* AID */
                         pos = skb_put(skb, 2);
-                        memcpy(pos + 2, &plid, 2);
+                        put_unaligned_le16(plid, pos + 2);
                 }
                 if (ieee80211_add_srates_ie(sdata, skb, true, band) ||
                     ieee80211_add_ext_srates_ie(sdata, skb, true, band) ||
@@ -343,14 +347,14 @@ static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
         *pos++ = ie_len;
         memcpy(pos, &peering_proto, 2);
         pos += 2;
-        memcpy(pos, &llid, 2);
+        put_unaligned_le16(llid, pos);
         pos += 2;
         if (include_plid) {
-                memcpy(pos, &plid, 2);
+                put_unaligned_le16(plid, pos);
                 pos += 2;
         }
         if (action == WLAN_SP_MESH_PEERING_CLOSE) {
-                memcpy(pos, &reason, 2);
+                put_unaligned_le16(reason, pos);
                 pos += 2;
         }
 
@@ -518,7 +522,7 @@ void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
             sta->plink_state == NL80211_PLINK_LISTEN &&
             sdata->u.mesh.accepting_plinks &&
             sdata->u.mesh.mshcfg.auto_open_plinks &&
-            rssi_threshold_check(sta, sdata))
+            rssi_threshold_check(sdata, sta))
                 changed = mesh_plink_open(sta);
 
         ieee80211_mps_frame_release(sta, elems);
@@ -530,9 +534,10 @@ out:
 static void mesh_plink_timer(unsigned long data)
 {
         struct sta_info *sta;
-        __le16 llid, plid, reason;
+        u16 reason = 0;
         struct ieee80211_sub_if_data *sdata;
         struct mesh_config *mshcfg;
+        enum ieee80211_self_protected_actioncode action = 0;
 
         /*
          * This STA is valid because sta_info_destroy() will
@@ -553,9 +558,6 @@ static void mesh_plink_timer(unsigned long data)
         mpl_dbg(sta->sdata,
                 "Mesh plink timer for %pM fired on state %s\n",
                 sta->sta.addr, mplstates[sta->plink_state]);
-        reason = 0;
-        llid = sta->llid;
-        plid = sta->plid;
         sdata = sta->sdata;
         mshcfg = &sdata->u.mesh.mshcfg;
 
@@ -574,33 +576,31 @@ static void mesh_plink_timer(unsigned long data)
                                              rand % sta->plink_timeout;
                         ++sta->plink_retries;
                         mod_plink_timer(sta, sta->plink_timeout);
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
-                                            sta->sta.addr, llid, 0, 0);
+                        action = WLAN_SP_MESH_PEERING_OPEN;
                         break;
                 }
-                reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES);
+                reason = WLAN_REASON_MESH_MAX_RETRIES;
                 /* fall through on else */
         case NL80211_PLINK_CNF_RCVD:
                 /* confirm timer */
                 if (!reason)
-                        reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT);
+                        reason = WLAN_REASON_MESH_CONFIRM_TIMEOUT;
                 sta->plink_state = NL80211_PLINK_HOLDING;
                 mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
-                spin_unlock_bh(&sta->lock);
-                mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
-                                    sta->sta.addr, llid, plid, reason);
+                action = WLAN_SP_MESH_PEERING_CLOSE;
                 break;
         case NL80211_PLINK_HOLDING:
                 /* holding timer */
                 del_timer(&sta->plink_timer);
                 mesh_plink_fsm_restart(sta);
-                spin_unlock_bh(&sta->lock);
                 break;
         default:
-                spin_unlock_bh(&sta->lock);
                 break;
         }
+        spin_unlock_bh(&sta->lock);
+        if (action)
+                mesh_plink_frame_tx(sdata, action, sta->sta.addr,
+                                    sta->llid, sta->plid, reason);
 }
 
 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
@@ -612,9 +612,40 @@ static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
         add_timer(&sta->plink_timer);
 }
 
+static bool llid_in_use(struct ieee80211_sub_if_data *sdata,
+                        u16 llid)
+{
+        struct ieee80211_local *local = sdata->local;
+        bool in_use = false;
+        struct sta_info *sta;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(sta, &local->sta_list, list) {
+                if (!memcmp(&sta->llid, &llid, sizeof(llid))) {
+                        in_use = true;
+                        break;
+                }
+        }
+        rcu_read_unlock();
+
+        return in_use;
+}
+
+static u16 mesh_get_new_llid(struct ieee80211_sub_if_data *sdata)
+{
+        u16 llid;
+
+        do {
+                get_random_bytes(&llid, sizeof(llid));
+                /* for mesh PS we still only have the AID range for TIM bits */
+                llid = (llid % IEEE80211_MAX_AID) + 1;
+        } while (llid_in_use(sdata, llid));
+
+        return llid;
+}
+
 u32 mesh_plink_open(struct sta_info *sta)
 {
-        __le16 llid;
         struct ieee80211_sub_if_data *sdata = sta->sdata;
         u32 changed;
 
@@ -622,8 +653,7 @@ u32 mesh_plink_open(struct sta_info *sta)
                 return 0;
 
         spin_lock_bh(&sta->lock);
-        get_random_bytes(&llid, 2);
-        sta->llid = llid;
+        sta->llid = mesh_get_new_llid(sdata);
         if (sta->plink_state != NL80211_PLINK_LISTEN &&
             sta->plink_state != NL80211_PLINK_BLOCKED) {
                 spin_unlock_bh(&sta->lock);
@@ -640,7 +670,7 @@ u32 mesh_plink_open(struct sta_info *sta)
         changed = ieee80211_mps_local_status_update(sdata);
 
         mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
-                            sta->sta.addr, llid, 0, 0);
+                            sta->sta.addr, sta->llid, 0, 0);
         return changed;
 }
 
@@ -656,390 +686,147 @@ u32 mesh_plink_block(struct sta_info *sta)
         return changed;
 }
 
-
-void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
-                         struct ieee80211_mgmt *mgmt, size_t len,
-                         struct ieee80211_rx_status *rx_status)
+static void mesh_plink_close(struct ieee80211_sub_if_data *sdata,
+                             struct sta_info *sta,
+                             enum plink_event event)
 {
         struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
-        struct ieee802_11_elems elems;
-        struct sta_info *sta;
-        enum plink_event event;
-        enum ieee80211_self_protected_actioncode ftype;
-        size_t baselen;
-        bool matches_local = true;
-        u8 ie_len;
-        u8 *baseaddr;
-        u32 changed = 0;
-        __le16 plid, llid, reason;
-
-        /* need action_code, aux */
-        if (len < IEEE80211_MIN_ACTION_SIZE + 3)
-                return;
-
-        if (sdata->u.mesh.user_mpm)
-                /* userspace must register for these */
-                return;
-
-        if (is_multicast_ether_addr(mgmt->da)) {
-                mpl_dbg(sdata,
-                        "Mesh plink: ignore frame from multicast address\n");
-                return;
-        }
-
-        baseaddr = mgmt->u.action.u.self_prot.variable;
-        baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
-        if (mgmt->u.action.u.self_prot.action_code ==
-                                                WLAN_SP_MESH_PEERING_CONFIRM) {
-                baseaddr += 4;
-                baselen += 4;
-        }
-        ieee802_11_parse_elems(baseaddr, len - baselen, true, &elems);
-
-        if (!elems.peering) {
-                mpl_dbg(sdata,
-                        "Mesh plink: missing necessary peer link ie\n");
-                return;
-        }
 
-        if (elems.rsn_len &&
-            sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
-                mpl_dbg(sdata,
-                        "Mesh plink: can't establish link with secure peer\n");
-                return;
-        }
+        u16 reason = (event == CLS_ACPT) ?
+                     WLAN_REASON_MESH_CLOSE : WLAN_REASON_MESH_CONFIG;
 
-        ftype = mgmt->u.action.u.self_prot.action_code;
-        ie_len = elems.peering_len;
-        if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
-            (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
-            (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
-                                                        && ie_len != 8)) {
-                mpl_dbg(sdata,
-                        "Mesh plink: incorrect plink ie length %d %d\n",
-                        ftype, ie_len);
-                return;
-        }
-
-        if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
-            (!elems.mesh_id || !elems.mesh_config)) {
-                mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
-                return;
-        }
-        /* Note the lines below are correct, the llid in the frame is the plid
-         * from the point of view of this host.
-         */
-        memcpy(&plid, PLINK_GET_LLID(elems.peering), 2);
-        if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
-            (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
-                memcpy(&llid, PLINK_GET_PLID(elems.peering), 2);
-
-        /* WARNING: Only for sta pointer, is dropped & re-acquired */
-        rcu_read_lock();
-
-        sta = sta_info_get(sdata, mgmt->sa);
-        if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) {
-                mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
-                rcu_read_unlock();
-                return;
-        }
-
-        if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
-            !rssi_threshold_check(sta, sdata)) {
-                mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
-                        mgmt->sa);
-                rcu_read_unlock();
-                return;
-        }
-
-        if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) {
-                mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
-                rcu_read_unlock();
-                return;
-        }
+        sta->reason = reason;
+        sta->plink_state = NL80211_PLINK_HOLDING;
+        mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
+}
 
-        if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
-                rcu_read_unlock();
-                return;
-        }
+static u32 mesh_plink_establish(struct ieee80211_sub_if_data *sdata,
+                                struct sta_info *sta)
+{
+        struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
+        u32 changed = 0;
 
-        /* Now we will figure out the appropriate event... */
-        event = PLINK_UNDEFINED;
-        if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
-            !mesh_matches_local(sdata, &elems)) {
-                matches_local = false;
-                switch (ftype) {
-                case WLAN_SP_MESH_PEERING_OPEN:
-                        event = OPN_RJCT;
-                        break;
-                case WLAN_SP_MESH_PEERING_CONFIRM:
-                        event = CNF_RJCT;
-                        break;
-                default:
-                        break;
-                }
-        }
+        del_timer(&sta->plink_timer);
+        sta->plink_state = NL80211_PLINK_ESTAB;
+        changed |= mesh_plink_inc_estab_count(sdata);
+        changed |= mesh_set_ht_prot_mode(sdata);
+        changed |= mesh_set_short_slot_time(sdata);
+        mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n", sta->sta.addr);
+        ieee80211_mps_sta_status_update(sta);
+        changed |= ieee80211_mps_set_sta_local_pm(sta, mshcfg->power_mode);
+        return changed;
+}
 
-        if (!sta && !matches_local) {
-                rcu_read_unlock();
-                reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
-                llid = 0;
-                mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
-                                    mgmt->sa, llid, plid, reason);
-                return;
-        } else if (!sta) {
-                /* ftype == WLAN_SP_MESH_PEERING_OPEN */
-                if (!mesh_plink_free_count(sdata)) {
-                        mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
-                        rcu_read_unlock();
-                        return;
-                }
-                event = OPN_ACPT;
-        } else if (matches_local) {
-                switch (ftype) {
-                case WLAN_SP_MESH_PEERING_OPEN:
-                        if (!mesh_plink_free_count(sdata) ||
-                            (sta->plid && sta->plid != plid))
-                                event = OPN_IGNR;
-                        else
-                                event = OPN_ACPT;
-                        break;
-                case WLAN_SP_MESH_PEERING_CONFIRM:
-                        if (!mesh_plink_free_count(sdata) ||
-                            (sta->llid != llid || sta->plid != plid))
-                                event = CNF_IGNR;
-                        else
-                                event = CNF_ACPT;
-                        break;
-                case WLAN_SP_MESH_PEERING_CLOSE:
-                        if (sta->plink_state == NL80211_PLINK_ESTAB)
-                                /* Do not check for llid or plid. This does not
-                                 * follow the standard but since multiple plinks
-                                 * per sta are not supported, it is necessary in
-                                 * order to avoid a livelock when MP A sees an
-                                 * establish peer link to MP B but MP B does not
-                                 * see it. This can be caused by a timeout in
-                                 * B's peer link establishment or B beign
-                                 * restarted.
-                                 */
-                                event = CLS_ACPT;
-                        else if (sta->plid != plid)
-                                event = CLS_IGNR;
-                        else if (ie_len == 7 && sta->llid != llid)
-                                event = CLS_IGNR;
-                        else
-                                event = CLS_ACPT;
-                        break;
-                default:
-                        mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
-                        rcu_read_unlock();
-                        return;
-                }
-        }
+/**
+ * mesh_plink_fsm - step @sta MPM based on @event
+ *
+ * @sdata: interface
+ * @sta: mesh neighbor
+ * @event: peering event
+ *
+ * Return: changed MBSS flags
+ */
+static u32 mesh_plink_fsm(struct ieee80211_sub_if_data *sdata,
+                          struct sta_info *sta, enum plink_event event)
+{
+        struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
+        enum ieee80211_self_protected_actioncode action = 0;
+        u32 changed = 0;
 
-        if (event == OPN_ACPT) {
-                rcu_read_unlock();
-                /* allocate sta entry if necessary and update info */
-                sta = mesh_sta_info_get(sdata, mgmt->sa, &elems);
-                if (!sta) {
-                        mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
-                        rcu_read_unlock();
-                        return;
-                }
-        }
+        mpl_dbg(sdata, "peer %pM in state %s got event %s\n", sta->sta.addr,
+                mplstates[sta->plink_state], mplevents[event]);
 
-        mpl_dbg(sdata, "peer %pM in state %s got event %s\n", mgmt->sa,
-                       mplstates[sta->plink_state], mplevents[event]);
-        reason = 0;
         spin_lock_bh(&sta->lock);
         switch (sta->plink_state) {
-                /* spin_unlock as soon as state is updated at each case */
         case NL80211_PLINK_LISTEN:
                 switch (event) {
                 case CLS_ACPT:
                         mesh_plink_fsm_restart(sta);
-                        spin_unlock_bh(&sta->lock);
                         break;
                 case OPN_ACPT:
                         sta->plink_state = NL80211_PLINK_OPN_RCVD;
-                        sta->plid = plid;
-                        get_random_bytes(&llid, 2);
-                        sta->llid = llid;
+                        sta->llid = mesh_get_new_llid(sdata);
                         mesh_plink_timer_set(sta,
                                              mshcfg->dot11MeshRetryTimeout);
 
                         /* set the non-peer mode to active during peering */
                         changed |= ieee80211_mps_local_status_update(sdata);
-
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_OPEN,
-                                            sta->sta.addr, llid, 0, 0);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_CONFIRM,
-                                            sta->sta.addr, llid, plid, 0);
+                        action = WLAN_SP_MESH_PEERING_OPEN;
                         break;
                 default:
-                        spin_unlock_bh(&sta->lock);
                         break;
                 }
                 break;
-
         case NL80211_PLINK_OPN_SNT:
                 switch (event) {
                 case OPN_RJCT:
                 case CNF_RJCT:
-                        reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
                 case CLS_ACPT:
-                        if (!reason)
-                                reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
-                        sta->reason = reason;
-                        sta->plink_state = NL80211_PLINK_HOLDING;
-                        if (!mod_plink_timer(sta,
-                                             mshcfg->dot11MeshHoldingTimeout))
-                                sta->ignore_plink_timer = true;
-
-                        llid = sta->llid;
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_CLOSE,
-                                            sta->sta.addr, llid, plid, reason);
+                        mesh_plink_close(sdata, sta, event);
+                        action = WLAN_SP_MESH_PEERING_CLOSE;
                         break;
                 case OPN_ACPT:
                         /* retry timer is left untouched */
                         sta->plink_state = NL80211_PLINK_OPN_RCVD;
-                        sta->plid = plid;
-                        llid = sta->llid;
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_CONFIRM,
-                                            sta->sta.addr, llid, plid, 0);
+                        action = WLAN_SP_MESH_PEERING_CONFIRM;
                         break;
                 case CNF_ACPT:
                         sta->plink_state = NL80211_PLINK_CNF_RCVD;
                         if (!mod_plink_timer(sta,
                                              mshcfg->dot11MeshConfirmTimeout))
                                 sta->ignore_plink_timer = true;
-
-                        spin_unlock_bh(&sta->lock);
                         break;
                 default:
-                        spin_unlock_bh(&sta->lock);
                         break;
                 }
                 break;
-
         case NL80211_PLINK_OPN_RCVD:
                 switch (event) {
                 case OPN_RJCT:
                 case CNF_RJCT:
-                        reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
                 case CLS_ACPT:
-                        if (!reason)
-                                reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
-                        sta->reason = reason;
-                        sta->plink_state = NL80211_PLINK_HOLDING;
-                        if (!mod_plink_timer(sta,
-                                             mshcfg->dot11MeshHoldingTimeout))
-                                sta->ignore_plink_timer = true;
-
-                        llid = sta->llid;
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
-                                            sta->sta.addr, llid, plid, reason);
+                        mesh_plink_close(sdata, sta, event);
+                        action = WLAN_SP_MESH_PEERING_CLOSE;
                         break;
                 case OPN_ACPT:
-                        llid = sta->llid;
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_CONFIRM,
-                                            sta->sta.addr, llid, plid, 0);
+                        action = WLAN_SP_MESH_PEERING_CONFIRM;
                         break;
                 case CNF_ACPT:
-                        del_timer(&sta->plink_timer);
-                        sta->plink_state = NL80211_PLINK_ESTAB;
-                        spin_unlock_bh(&sta->lock);
-                        changed |= mesh_plink_inc_estab_count(sdata);
-                        changed |= mesh_set_ht_prot_mode(sdata);
-                        changed |= mesh_set_short_slot_time(sdata);
-                        mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
-                                sta->sta.addr);
-                        ieee80211_mps_sta_status_update(sta);
-                        changed |= ieee80211_mps_set_sta_local_pm(sta,
-                                                       mshcfg->power_mode);
+                        changed |= mesh_plink_establish(sdata, sta);
                         break;
                 default:
-                        spin_unlock_bh(&sta->lock);
                         break;
                 }
                 break;
-
         case NL80211_PLINK_CNF_RCVD:
                 switch (event) {
                 case OPN_RJCT:
                 case CNF_RJCT:
-                        reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
                 case CLS_ACPT:
-                        if (!reason)
-                                reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
-                        sta->reason = reason;
-                        sta->plink_state = NL80211_PLINK_HOLDING;
-                        if (!mod_plink_timer(sta,
-                                             mshcfg->dot11MeshHoldingTimeout))
-                                sta->ignore_plink_timer = true;
-
-                        llid = sta->llid;
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_CLOSE,
-                                            sta->sta.addr, llid, plid, reason);
+                        mesh_plink_close(sdata, sta, event);
+                        action = WLAN_SP_MESH_PEERING_CLOSE;
                         break;
                 case OPN_ACPT:
-                        del_timer(&sta->plink_timer);
-                        sta->plink_state = NL80211_PLINK_ESTAB;
-                        spin_unlock_bh(&sta->lock);
-                        changed |= mesh_plink_inc_estab_count(sdata);
-                        changed |= mesh_set_ht_prot_mode(sdata);
-                        changed |= mesh_set_short_slot_time(sdata);
-                        mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
-                                sta->sta.addr);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_CONFIRM,
-                                            sta->sta.addr, llid, plid, 0);
-                        ieee80211_mps_sta_status_update(sta);
-                        changed |= ieee80211_mps_set_sta_local_pm(sta,
-                                                        mshcfg->power_mode);
+                        changed |= mesh_plink_establish(sdata, sta);
+                        action = WLAN_SP_MESH_PEERING_CONFIRM;
                         break;
                 default:
-                        spin_unlock_bh(&sta->lock);
                         break;
                 }
                 break;
-
         case NL80211_PLINK_ESTAB:
                 switch (event) {
                 case CLS_ACPT:
-                        reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
-                        sta->reason = reason;
                         changed |= __mesh_plink_deactivate(sta);
-                        sta->plink_state = NL80211_PLINK_HOLDING;
-                        llid = sta->llid;
-                        mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
-                        spin_unlock_bh(&sta->lock);
                         changed |= mesh_set_ht_prot_mode(sdata);
                         changed |= mesh_set_short_slot_time(sdata);
-                        mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
-                                            sta->sta.addr, llid, plid, reason);
+                        mesh_plink_close(sdata, sta, event);
+                        action = WLAN_SP_MESH_PEERING_CLOSE;
                         break;
                 case OPN_ACPT:
-                        llid = sta->llid;
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata,
-                                            WLAN_SP_MESH_PEERING_CONFIRM,
-                                            sta->sta.addr, llid, plid, 0);
+                        action = WLAN_SP_MESH_PEERING_CONFIRM;
                         break;
                 default:
-                        spin_unlock_bh(&sta->lock);
                         break;
                 }
                 break;
@@ -1049,32 +836,271 @@ void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
                         if (del_timer(&sta->plink_timer))
                                 sta->ignore_plink_timer = 1;
                         mesh_plink_fsm_restart(sta);
-                        spin_unlock_bh(&sta->lock);
                         break;
                 case OPN_ACPT:
                 case CNF_ACPT:
                 case OPN_RJCT:
                 case CNF_RJCT:
-                        llid = sta->llid;
-                        reason = sta->reason;
-                        spin_unlock_bh(&sta->lock);
-                        mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
-                                            sta->sta.addr, llid, plid, reason);
+                        action = WLAN_SP_MESH_PEERING_CLOSE;
                         break;
                 default:
-                        spin_unlock_bh(&sta->lock);
+                        break;
                 }
                 break;
         default:
                 /* should not get here, PLINK_BLOCKED is dealt with at the
                  * beginning of the function
                  */
-                spin_unlock_bh(&sta->lock);
                 break;
         }
+        spin_unlock_bh(&sta->lock);
+        if (action) {
+                mesh_plink_frame_tx(sdata, action, sta->sta.addr,
+                                    sta->llid, sta->plid, sta->reason);
+
+                /* also send confirm in open case */
+                if (action == WLAN_SP_MESH_PEERING_OPEN) {
+                        mesh_plink_frame_tx(sdata,
+                                            WLAN_SP_MESH_PEERING_CONFIRM,
+                                            sta->sta.addr, sta->llid,
+                                            sta->plid, 0);
+                }
+        }
+
+        return changed;
+}
+
+/*
+ * mesh_plink_get_event - get correct MPM event
+ *
+ * @sdata: interface
+ * @sta: peer, leave NULL if processing a frame from a new suitable peer
+ * @elems: peering management IEs
+ * @ftype: frame type
+ * @llid: peer's peer link ID
+ * @plid: peer's local link ID
+ *
+ * Return: new peering event for @sta, but PLINK_UNDEFINED should be treated as
+ * an error.
+ */
+static enum plink_event
+mesh_plink_get_event(struct ieee80211_sub_if_data *sdata,
+                     struct sta_info *sta,
+                     struct ieee802_11_elems *elems,
+                     enum ieee80211_self_protected_actioncode ftype,
+                     u16 llid, u16 plid)
+{
+        enum plink_event event = PLINK_UNDEFINED;
+        u8 ie_len = elems->peering_len;
+        bool matches_local;
+
+        matches_local = (ftype == WLAN_SP_MESH_PEERING_CLOSE ||
+                         mesh_matches_local(sdata, elems));
+
+        /* deny open request from non-matching peer */
+        if (!matches_local && !sta) {
+                event = OPN_RJCT;
+                goto out;
+        }
+
+        if (!sta) {
+                if (ftype != WLAN_SP_MESH_PEERING_OPEN) {
+                        mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
+                        goto out;
+                }
+                /* ftype == WLAN_SP_MESH_PEERING_OPEN */
+                if (!mesh_plink_free_count(sdata)) {
+                        mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
+                        goto out;
+                }
+        } else {
+                if (!test_sta_flag(sta, WLAN_STA_AUTH)) {
+                        mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
+                        goto out;
+                }
+                if (sta->plink_state == NL80211_PLINK_BLOCKED)
+                        goto out;
+        }
+
+        /* new matching peer */
+        if (!sta) {
+                event = OPN_ACPT;
+                goto out;
+        }
+
+        switch (ftype) {
+        case WLAN_SP_MESH_PEERING_OPEN:
+                if (!matches_local)
+                        event = OPN_RJCT;
+                if (!mesh_plink_free_count(sdata) ||
+                    (sta->plid && sta->plid != plid))
+                        event = OPN_IGNR;
+                else
+                        event = OPN_ACPT;
+                break;
+        case WLAN_SP_MESH_PEERING_CONFIRM:
+                if (!matches_local)
+                        event = CNF_RJCT;
+                if (!mesh_plink_free_count(sdata) ||
+                    (sta->llid != llid || sta->plid != plid))
+                        event = CNF_IGNR;
+                else
+                        event = CNF_ACPT;
+                break;
+        case WLAN_SP_MESH_PEERING_CLOSE:
+                if (sta->plink_state == NL80211_PLINK_ESTAB)
+                        /* Do not check for llid or plid. This does not
+                         * follow the standard but since multiple plinks
+                         * per sta are not supported, it is necessary in
+                         * order to avoid a livelock when MP A sees an
+                         * establish peer link to MP B but MP B does not
+                         * see it. This can be caused by a timeout in
+                         * B's peer link establishment or B beign
+                         * restarted.
+                         */
+                        event = CLS_ACPT;
+                else if (sta->plid != plid)
+                        event = CLS_IGNR;
+                else if (ie_len == 8 && sta->llid != llid)
+                        event = CLS_IGNR;
+                else
+                        event = CLS_ACPT;
+                break;
+        default:
+                mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
+                break;
+        }
+
+out:
+        return event;
+}
 
+static void
+mesh_process_plink_frame(struct ieee80211_sub_if_data *sdata,
+                         struct ieee80211_mgmt *mgmt,
+                         struct ieee802_11_elems *elems)
+{
+
+        struct sta_info *sta;
+        enum plink_event event;
+        enum ieee80211_self_protected_actioncode ftype;
+        u32 changed = 0;
+        u8 ie_len = elems->peering_len;
+        __le16 _plid, _llid;
+        u16 plid, llid = 0;
+
+        if (!elems->peering) {
+                mpl_dbg(sdata,
+                        "Mesh plink: missing necessary peer link ie\n");
+                return;
+        }
+
+        if (elems->rsn_len &&
+            sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
+                mpl_dbg(sdata,
+                        "Mesh plink: can't establish link with secure peer\n");
+                return;
+        }
+
+        ftype = mgmt->u.action.u.self_prot.action_code;
+        if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
+            (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
+            (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
+                                                        && ie_len != 8)) {
+                mpl_dbg(sdata,
+                        "Mesh plink: incorrect plink ie length %d %d\n",
+                        ftype, ie_len);
+                return;
+        }
+
+        if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
+            (!elems->mesh_id || !elems->mesh_config)) {
+                mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
+                return;
+        }
+        /* Note the lines below are correct, the llid in the frame is the plid
+         * from the point of view of this host.
+         */
+        memcpy(&_plid, PLINK_GET_LLID(elems->peering), sizeof(__le16));
+        plid = le16_to_cpu(_plid);
+        if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
+            (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8)) {
+                memcpy(&_llid, PLINK_GET_PLID(elems->peering), sizeof(__le16));
+                llid = le16_to_cpu(_llid);
+        }
+
+        /* WARNING: Only for sta pointer, is dropped & re-acquired */
+        rcu_read_lock();
+
+        sta = sta_info_get(sdata, mgmt->sa);
+
+        if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
+            !rssi_threshold_check(sdata, sta)) {
+                mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
+                        mgmt->sa);
+                goto unlock_rcu;
+        }
+
+        /* Now we will figure out the appropriate event... */
+        event = mesh_plink_get_event(sdata, sta, elems, ftype, llid, plid);
+
+        if (event == OPN_ACPT) {
+                rcu_read_unlock();
+                /* allocate sta entry if necessary and update info */
+                sta = mesh_sta_info_get(sdata, mgmt->sa, elems);
+                if (!sta) {
+                        mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
+                        goto unlock_rcu;
+                }
+                sta->plid = plid;
+        } else if (!sta && event == OPN_RJCT) {
+                mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
+                                    mgmt->sa, 0, plid,
+                                    WLAN_REASON_MESH_CONFIG);
+                goto unlock_rcu;
+        } else if (!sta || event == PLINK_UNDEFINED) {
+                /* something went wrong */
+                goto unlock_rcu;
+        }
+
+        changed |= mesh_plink_fsm(sdata, sta, event);
+
+unlock_rcu:
         rcu_read_unlock();
 
         if (changed)
                 ieee80211_mbss_info_change_notify(sdata, changed);
 }
+
+void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
+                         struct ieee80211_mgmt *mgmt, size_t len,
+                         struct ieee80211_rx_status *rx_status)
+{
+        struct ieee802_11_elems elems;
+        size_t baselen;
+        u8 *baseaddr;
+
+        /* need action_code, aux */
+        if (len < IEEE80211_MIN_ACTION_SIZE + 3)
+                return;
+
+        if (sdata->u.mesh.user_mpm)
+                /* userspace must register for these */
+                return;
+
+        if (is_multicast_ether_addr(mgmt->da)) {
+                mpl_dbg(sdata,
+                        "Mesh plink: ignore frame from multicast address\n");
+                return;
+        }
+
+        baseaddr = mgmt->u.action.u.self_prot.variable;
+        baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
+        if (mgmt->u.action.u.self_prot.action_code ==
+                                                WLAN_SP_MESH_PEERING_CONFIRM) {
+                baseaddr += 4;
+                baselen += 4;
+        }
+        ieee802_11_parse_elems(baseaddr, len - baselen, true, &elems);
+        mesh_process_plink_frame(sdata, mgmt, &elems);
+}
diff --git a/net/mac80211/mesh_ps.c b/net/mac80211/mesh_ps.c
index 0f79b78b5e86..2802f9d9279d 100644
--- a/net/mac80211/mesh_ps.c
+++ b/net/mac80211/mesh_ps.c
@@ -576,10 +576,9 @@ void ieee80211_mps_frame_release(struct sta_info *sta,
         int ac, buffer_local = 0;
         bool has_buffered = false;
 
-        /* TIM map only for LLID <= IEEE80211_MAX_AID */
         if (sta->plink_state == NL80211_PLINK_ESTAB)
                 has_buffered = ieee80211_check_tim(elems->tim, elems->tim_len,
-                                le16_to_cpu(sta->llid) % IEEE80211_MAX_AID);
+                                                   sta->llid);
 
         if (has_buffered)
                 mps_dbg(sta->sdata, "%pM indicates buffered frames\n",
diff --git a/net/mac80211/mesh_sync.c b/net/mac80211/mesh_sync.c
index 05a256b38e24..d1cf2d553499 100644
--- a/net/mac80211/mesh_sync.c
+++ b/net/mac80211/mesh_sync.c
@@ -92,12 +92,20 @@ static void mesh_sync_offset_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
         if (stype != IEEE80211_STYPE_BEACON)
                 return;
 
-        /* The current tsf is a first approximation for the timestamp
-         * for the received beacon.  Further down we try to get a
-         * better value from the rx_status->mactime field if
-         * available. Also we have to call drv_get_tsf() before
-         * entering the rcu-read section.*/
-        t_r = drv_get_tsf(local, sdata);
+        /*
+         * Get time when timestamp field was received.  If we don't
+         * have rx timestamps, then use current tsf as an approximation.
+         * drv_get_tsf() must be called before entering the rcu-read
+         * section.
+         */
+        if (ieee80211_have_rx_timestamp(rx_status))
+                t_r = ieee80211_calculate_rx_timestamp(local, rx_status,
+                                                       24 + 12 +
+                                                       elems->total_len +
+                                                       FCS_LEN,
+                                                       24);
+        else
+                t_r = drv_get_tsf(local, sdata);
 
         rcu_read_lock();
         sta = sta_info_get(sdata, mgmt->sa);
@@ -117,14 +125,6 @@ static void mesh_sync_offset_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
                 goto no_sync;
         }
 
-        if (ieee80211_have_rx_timestamp(rx_status))
-                /* time when timestamp field was received */
-                t_r = ieee80211_calculate_rx_timestamp(local, rx_status,
-                                                       24 + 12 +
-                                                       elems->total_len +
-                                                       FCS_LEN,
-                                                       24);
-
         /* Timing offset calculation (see 13.13.2.2.2) */
         t_t = le64_to_cpu(mgmt->u.beacon.timestamp);
         sta->t_offset = t_t - t_r;
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index b3a3ce316656..900ead344f5b 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -330,6 +330,16 @@ static int ieee80211_config_bw(struct ieee80211_sub_if_data *sdata,
         if (WARN_ON_ONCE(!sta))
                 return -EINVAL;
 
+        /*
+         * if bss configuration changed store the new one -
+         * this may be applicable even if channel is identical
+         */
+        ht_opmode = le16_to_cpu(ht_oper->operation_mode);
+        if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
+                *changed |= BSS_CHANGED_HT;
+                sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
+        }
+
         chan = sdata->vif.bss_conf.chandef.chan;
         sband = local->hw.wiphy->bands[chan->band];
 
@@ -416,14 +426,6 @@ static int ieee80211_config_bw(struct ieee80211_sub_if_data *sdata,
                                          IEEE80211_RC_BW_CHANGED);
         }
 
-        ht_opmode = le16_to_cpu(ht_oper->operation_mode);
-
-        /* if bss configuration changed store the new one */
-        if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
-                *changed |= BSS_CHANGED_HT;
-                sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
-        }
-
         return 0;
 }
 
@@ -714,7 +716,7 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
         }
 
         /* if present, add any custom IEs that go before HT */
-        if (assoc_data->ie_len && assoc_data->ie) {
+        if (assoc_data->ie_len) {
                 static const u8 before_ht[] = {
                         WLAN_EID_SSID,
                         WLAN_EID_SUPP_RATES,
@@ -748,7 +750,7 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
                                      &assoc_data->ap_vht_cap);
 
         /* if present, add any custom non-vendor IEs that go after HT */
-        if (assoc_data->ie_len && assoc_data->ie) {
+        if (assoc_data->ie_len) {
                 noffset = ieee80211_ie_split_vendor(assoc_data->ie,
                                                     assoc_data->ie_len,
                                                     offset);
@@ -779,7 +781,7 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
         }
 
         /* add any remaining custom (i.e. vendor specific here) IEs */
-        if (assoc_data->ie_len && assoc_data->ie) {
+        if (assoc_data->ie_len) {
                 noffset = assoc_data->ie_len;
                 pos = skb_put(skb, noffset - offset);
                 memcpy(pos, assoc_data->ie + offset, noffset - offset);
@@ -886,8 +888,7 @@ static void ieee80211_chswitch_work(struct work_struct *work)
         if (!ifmgd->associated)
                 goto out;
 
-        ret = ieee80211_vif_change_channel(sdata, &local->csa_chandef,
-                                           &changed);
+        ret = ieee80211_vif_change_channel(sdata, &changed);
         if (ret) {
                 sdata_info(sdata,
                            "vif channel switch failed, disconnecting\n");
@@ -897,7 +898,7 @@ static void ieee80211_chswitch_work(struct work_struct *work)
         }
 
         if (!local->use_chanctx) {
-                local->_oper_chandef = local->csa_chandef;
+                local->_oper_chandef = sdata->csa_chandef;
                 /* Call "hw_config" only if doing sw channel switch.
                  * Otherwise update the channel directly
                  */
@@ -908,7 +909,7 @@ static void ieee80211_chswitch_work(struct work_struct *work)
         }
 
         /* XXX: shouldn't really modify cfg80211-owned data! */
-        ifmgd->associated->channel = local->csa_chandef.chan;
+        ifmgd->associated->channel = sdata->csa_chandef.chan;
 
         /* XXX: wait for a beacon first? */
         ieee80211_wake_queues_by_reason(&local->hw,
@@ -1035,7 +1036,7 @@ ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
         }
         mutex_unlock(&local->chanctx_mtx);
 
-        local->csa_chandef = csa_ie.chandef;
+        sdata->csa_chandef = csa_ie.chandef;
 
         if (csa_ie.mode)
                 ieee80211_stop_queues_by_reason(&local->hw,
@@ -1398,10 +1399,12 @@ void ieee80211_dfs_cac_timer_work(struct work_struct *work)
         struct ieee80211_sub_if_data *sdata =
                 container_of(delayed_work, struct ieee80211_sub_if_data,
                              dfs_cac_timer_work);
+        struct cfg80211_chan_def chandef = sdata->vif.bss_conf.chandef;
 
         ieee80211_vif_release_channel(sdata);
-
-        cfg80211_cac_event(sdata->dev, NL80211_RADAR_CAC_FINISHED, GFP_KERNEL);
+        cfg80211_cac_event(sdata->dev, &chandef,
+                           NL80211_RADAR_CAC_FINISHED,
+                           GFP_KERNEL);
 }
 
 /* MLME */
@@ -1745,6 +1748,8 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
 
         ifmgd->flags = 0;
         ieee80211_vif_release_channel(sdata);
+
+        sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
 }
 
 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
@@ -4191,6 +4196,8 @@ int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
 
         sdata->control_port_protocol = req->crypto.control_port_ethertype;
         sdata->control_port_no_encrypt = req->crypto.control_port_no_encrypt;
+        sdata->encrypt_headroom = ieee80211_cs_headroom(local, &req->crypto,
+                                                        sdata->vif.type);
 
         /* kick off associate process */
 
diff --git a/net/mac80211/rate.h b/net/mac80211/rate.h
index 505bc0dea074..b95e16c07081 100644
--- a/net/mac80211/rate.h
+++ b/net/mac80211/rate.h
@@ -54,6 +54,8 @@ static inline void rate_control_rate_init(struct sta_info *sta)
         struct ieee80211_supported_band *sband;
         struct ieee80211_chanctx_conf *chanctx_conf;
 
+        ieee80211_sta_set_rx_nss(sta);
+
         if (!ref)
                 return;
 
@@ -67,8 +69,6 @@ static inline void rate_control_rate_init(struct sta_info *sta)
 
         sband = local->hw.wiphy->bands[chanctx_conf->def.chan->band];
 
-        ieee80211_sta_set_rx_nss(sta);
-
         ref->ops->rate_init(ref->priv, sband, &chanctx_conf->def, ista,
                             priv_sta);
         rcu_read_unlock();
diff --git a/net/mac80211/rc80211_minstrel.c b/net/mac80211/rc80211_minstrel.c
index 7fa1b36e6202..d2f19f7e7091 100644
--- a/net/mac80211/rc80211_minstrel.c
+++ b/net/mac80211/rc80211_minstrel.c
@@ -422,10 +422,9 @@ init_sample_table(struct minstrel_sta_info *mi)
         memset(mi->sample_table, 0xff, SAMPLE_COLUMNS * mi->n_rates);
 
         for (col = 0; col < SAMPLE_COLUMNS; col++) {
+                prandom_bytes(rnd, sizeof(rnd));
                 for (i = 0; i < mi->n_rates; i++) {
-                        get_random_bytes(rnd, sizeof(rnd));
                         new_idx = (i + rnd[i & 7]) % mi->n_rates;
-
                         while (SAMPLE_TBL(mi, new_idx, col) != 0xff)
                                 new_idx = (new_idx + 1) % mi->n_rates;
 
diff --git a/net/mac80211/rc80211_minstrel_ht.c b/net/mac80211/rc80211_minstrel_ht.c
index 4096ff6cc24f..d2ed18d82fe1 100644
--- a/net/mac80211/rc80211_minstrel_ht.c
+++ b/net/mac80211/rc80211_minstrel_ht.c
@@ -135,7 +135,7 @@ minstrel_ht_update_rates(struct minstrel_priv *mp, struct minstrel_ht_sta *mi);
 static int
 minstrel_ht_get_group_idx(struct ieee80211_tx_rate *rate)
 {
-        return GROUP_IDX((rate->idx / MCS_GROUP_RATES) + 1,
+        return GROUP_IDX((rate->idx / 8) + 1,
                          !!(rate->flags & IEEE80211_TX_RC_SHORT_GI),
                          !!(rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH));
 }
@@ -148,7 +148,7 @@ minstrel_ht_get_stats(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
 
         if (rate->flags & IEEE80211_TX_RC_MCS) {
                 group = minstrel_ht_get_group_idx(rate);
-                idx = rate->idx % MCS_GROUP_RATES;
+                idx = rate->idx % 8;
         } else {
                 group = MINSTREL_CCK_GROUP;
 
@@ -637,8 +637,7 @@ minstrel_ht_set_rate(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
                 idx = mp->cck_rates[index % ARRAY_SIZE(mp->cck_rates)];
                 flags = 0;
         } else {
-                idx = index % MCS_GROUP_RATES +
-                      (group->streams - 1) * MCS_GROUP_RATES;
+                idx = index % MCS_GROUP_RATES + (group->streams - 1) * 8;
                 flags = IEEE80211_TX_RC_MCS | group->flags;
         }
 
@@ -702,12 +701,16 @@ minstrel_get_sample_rate(struct minstrel_priv *mp, struct minstrel_ht_sta *mi)
         if (!mi->sample_tries)
                 return -1;
 
-        mg = &mi->groups[mi->sample_group];
+        sample_group = mi->sample_group;
+        mg = &mi->groups[sample_group];
         sample_idx = sample_table[mg->column][mg->index];
+        minstrel_next_sample_idx(mi);
+
+        if (!(mg->supported & BIT(sample_idx)))
+                return -1;
+
         mr = &mg->rates[sample_idx];
-        sample_group = mi->sample_group;
         sample_idx += sample_group * MCS_GROUP_RATES;
-        minstrel_next_sample_idx(mi);
 
         /*
          * Sampling might add some overhead (RTS, no aggregation)
@@ -818,7 +821,7 @@ minstrel_ht_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta,
         }
 
         rate->idx = sample_idx % MCS_GROUP_RATES +
-                    (sample_group->streams - 1) * MCS_GROUP_RATES;
+                    (sample_group->streams - 1) * 8;
         rate->flags = IEEE80211_TX_RC_MCS | sample_group->flags;
 }
 
@@ -1053,10 +1056,9 @@ init_sample_table(void)
 
         memset(sample_table, 0xff, sizeof(sample_table));
         for (col = 0; col < SAMPLE_COLUMNS; col++) {
+                prandom_bytes(rnd, sizeof(rnd));
                 for (i = 0; i < MCS_GROUP_RATES; i++) {
-                        get_random_bytes(rnd, sizeof(rnd));
                         new_idx = (i + rnd[i]) % MCS_GROUP_RATES;
-
                         while (sample_table[col][new_idx] != 0xff)
                                 new_idx = (new_idx + 1) % MCS_GROUP_RATES;
 
diff --git a/net/mac80211/rc80211_minstrel_ht_debugfs.c b/net/mac80211/rc80211_minstrel_ht_debugfs.c
index df44a5ad8270..3e7d793de0c3 100644
--- a/net/mac80211/rc80211_minstrel_ht_debugfs.c
+++ b/net/mac80211/rc80211_minstrel_ht_debugfs.c
@@ -54,8 +54,7 @@ minstrel_ht_stats_dump(struct minstrel_ht_sta *mi, int i, char *p)
                         int r = bitrates[j % 4];
                         p += sprintf(p, " %2u.%1uM", r / 10, r % 10);
                 } else {
-                        p += sprintf(p, " MCS%-2u", (mg->streams - 1) *
-                                         MCS_GROUP_RATES + j);
+                        p += sprintf(p, " MCS%-2u", (mg->streams - 1) * 8 + j);
                 }
 
                 tp = mr->cur_tp / 10;
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index 2b0debb0422b..2dfa75522733 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -638,6 +638,27 @@ static int ieee80211_get_mmie_keyidx(struct sk_buff *skb)
         return le16_to_cpu(mmie->key_id);
 }
 
+static int iwl80211_get_cs_keyid(const struct ieee80211_cipher_scheme *cs,
+                                 struct sk_buff *skb)
+{
+        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+        __le16 fc;
+        int hdrlen;
+        u8 keyid;
+
+        fc = hdr->frame_control;
+        hdrlen = ieee80211_hdrlen(fc);
+
+        if (skb->len < hdrlen + cs->hdr_len)
+                return -EINVAL;
+
+        skb_copy_bits(skb, hdrlen + cs->key_idx_off, &keyid, 1);
+        keyid &= cs->key_idx_mask;
+        keyid >>= cs->key_idx_shift;
+
+        return keyid;
+}
+
 static ieee80211_rx_result ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
 {
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
@@ -729,9 +750,7 @@ static void ieee80211_release_reorder_frames(struct ieee80211_sub_if_data *sdata
         lockdep_assert_held(&tid_agg_rx->reorder_lock);
 
         while (ieee80211_sn_less(tid_agg_rx->head_seq_num, head_seq_num)) {
-                index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
-                                         tid_agg_rx->ssn) %
-                                                        tid_agg_rx->buf_size;
+                index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
                 ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
                                                 frames);
         }
@@ -757,8 +776,7 @@ static void ieee80211_sta_reorder_release(struct ieee80211_sub_if_data *sdata,
         lockdep_assert_held(&tid_agg_rx->reorder_lock);
 
         /* release the buffer until next missing frame */
-        index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
-                                 tid_agg_rx->ssn) % tid_agg_rx->buf_size;
+        index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
         if (!tid_agg_rx->reorder_buf[index] &&
             tid_agg_rx->stored_mpdu_num) {
                 /*
@@ -793,15 +811,11 @@ static void ieee80211_sta_reorder_release(struct ieee80211_sub_if_data *sdata,
         } else while (tid_agg_rx->reorder_buf[index]) {
                 ieee80211_release_reorder_frame(sdata, tid_agg_rx, index,
                                                 frames);
-                index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
-                                         tid_agg_rx->ssn) %
-                                                        tid_agg_rx->buf_size;
+                index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
         }
 
         if (tid_agg_rx->stored_mpdu_num) {
-                j = index = ieee80211_sn_sub(tid_agg_rx->head_seq_num,
-                                             tid_agg_rx->ssn) %
-                                                        tid_agg_rx->buf_size;
+                j = index = tid_agg_rx->head_seq_num % tid_agg_rx->buf_size;
 
                 for (; j != (index - 1) % tid_agg_rx->buf_size;
                      j = (j + 1) % tid_agg_rx->buf_size) {
@@ -861,8 +875,7 @@ static bool ieee80211_sta_manage_reorder_buf(struct ieee80211_sub_if_data *sdata
 
         /* Now the new frame is always in the range of the reordering buffer */
 
-        index = ieee80211_sn_sub(mpdu_seq_num,
-                                 tid_agg_rx->ssn) % tid_agg_rx->buf_size;
+        index = mpdu_seq_num % tid_agg_rx->buf_size;
 
         /* check if we already stored this frame */
         if (tid_agg_rx->reorder_buf[index]) {
@@ -1369,6 +1382,7 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
         struct ieee80211_key *sta_ptk = NULL;
         int mmie_keyidx = -1;
         __le16 fc;
+        const struct ieee80211_cipher_scheme *cs = NULL;
 
         /*
          * Key selection 101
@@ -1406,11 +1420,19 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
 
         /* start without a key */
         rx->key = NULL;
+        fc = hdr->frame_control;
 
-        if (rx->sta)
-                sta_ptk = rcu_dereference(rx->sta->ptk);
+        if (rx->sta) {
+                int keyid = rx->sta->ptk_idx;
 
-        fc = hdr->frame_control;
+                if (ieee80211_has_protected(fc) && rx->sta->cipher_scheme) {
+                        cs = rx->sta->cipher_scheme;
+                        keyid = iwl80211_get_cs_keyid(cs, rx->skb);
+                        if (unlikely(keyid < 0))
+                                return RX_DROP_UNUSABLE;
+                }
+                sta_ptk = rcu_dereference(rx->sta->ptk[keyid]);
+        }
 
         if (!ieee80211_has_protected(fc))
                 mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
@@ -1472,6 +1494,7 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
                 return RX_CONTINUE;
         } else {
                 u8 keyid;
+
                 /*
                  * The device doesn't give us the IV so we won't be
                  * able to look up the key. That's ok though, we
@@ -1487,15 +1510,21 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
 
                 hdrlen = ieee80211_hdrlen(fc);
 
-                if (rx->skb->len < 8 + hdrlen)
-                        return RX_DROP_UNUSABLE; /* TODO: count this? */
+                if (cs) {
+                        keyidx = iwl80211_get_cs_keyid(cs, rx->skb);
 
-                /*
-                 * no need to call ieee80211_wep_get_keyidx,
-                 * it verifies a bunch of things we've done already
-                 */
-                skb_copy_bits(rx->skb, hdrlen + 3, &keyid, 1);
-                keyidx = keyid >> 6;
+                        if (unlikely(keyidx < 0))
+                                return RX_DROP_UNUSABLE;
+                } else {
+                        if (rx->skb->len < 8 + hdrlen)
+                                return RX_DROP_UNUSABLE; /* TODO: count this? */
+                        /*
+                         * no need to call ieee80211_wep_get_keyidx,
+                         * it verifies a bunch of things we've done already
+                         */
+                        skb_copy_bits(rx->skb, hdrlen + 3, &keyid, 1);
+                        keyidx = keyid >> 6;
+                }
 
                 /* check per-station GTK first, if multicast packet */
                 if (is_multicast_ether_addr(hdr->addr1) && rx->sta)
@@ -1543,11 +1572,7 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
                 result = ieee80211_crypto_aes_cmac_decrypt(rx);
                 break;
         default:
-                /*
-                 * We can reach here only with HW-only algorithms
-                 * but why didn't it decrypt the frame?!
-                 */
-                return RX_DROP_UNUSABLE;
+                result = ieee80211_crypto_hw_decrypt(rx);
         }
 
         /* the hdr variable is invalid after the decrypt handlers */
@@ -2057,7 +2082,6 @@ ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
         struct ieee80211_sub_if_data *sdata = rx->sdata;
         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
         struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
-        __le16 reason = cpu_to_le16(WLAN_REASON_MESH_PATH_NOFORWARD);
         u16 q, hdrlen;
 
         hdr = (struct ieee80211_hdr *) skb->data;
@@ -2165,7 +2189,9 @@ ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
         } else {
                 /* unable to resolve next hop */
                 mesh_path_error_tx(sdata, ifmsh->mshcfg.element_ttl,
-                                   fwd_hdr->addr3, 0, reason, fwd_hdr->addr2);
+                                   fwd_hdr->addr3, 0,
+                                   WLAN_REASON_MESH_PATH_NOFORWARD,
+                                   fwd_hdr->addr2);
                 IEEE80211_IFSTA_MESH_CTR_INC(ifmsh, dropped_frames_no_route);
                 kfree_skb(fwd_skb);
                 return RX_DROP_MONITOR;
diff --git a/net/mac80211/scan.c b/net/mac80211/scan.c
index bcc4833d7542..4d73c46df862 100644
--- a/net/mac80211/scan.c
+++ b/net/mac80211/scan.c
@@ -526,7 +526,7 @@ static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
                 ieee80211_hw_config(local, 0);
 
                 if ((req->channels[0]->flags &
-                     IEEE80211_CHAN_PASSIVE_SCAN) ||
+                     IEEE80211_CHAN_NO_IR) ||
                     !local->scan_req->n_ssids) {
                         next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
                 } else {
@@ -572,7 +572,7 @@ ieee80211_scan_get_channel_time(struct ieee80211_channel *chan)
          * TODO: channel switching also consumes quite some time,
          * add that delay as well to get a better estimation
          */
-        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
+        if (chan->flags & IEEE80211_CHAN_NO_IR)
                 return IEEE80211_PASSIVE_CHANNEL_TIME;
         return IEEE80211_PROBE_DELAY + IEEE80211_CHANNEL_TIME;
 }
@@ -696,7 +696,7 @@ static void ieee80211_scan_state_set_channel(struct ieee80211_local *local,
          *
          * In any case, it is not necessary for a passive scan.
          */
-        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
+        if (chan->flags & IEEE80211_CHAN_NO_IR ||
             !local->scan_req->n_ssids) {
                 *next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
                 local->next_scan_state = SCAN_DECISION;
@@ -881,7 +881,7 @@ int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
                                 struct ieee80211_channel *tmp_ch =
                                     &local->hw.wiphy->bands[band]->channels[i];
 
-                                if (tmp_ch->flags & (IEEE80211_CHAN_NO_IBSS |
+                                if (tmp_ch->flags & (IEEE80211_CHAN_NO_IR |
                                                      IEEE80211_CHAN_DISABLED))
                                         continue;
 
@@ -895,7 +895,7 @@ int ieee80211_request_ibss_scan(struct ieee80211_sub_if_data *sdata,
 
                 local->int_scan_req->n_channels = n_ch;
         } else {
-                if (WARN_ON_ONCE(chan->flags & (IEEE80211_CHAN_NO_IBSS |
+                if (WARN_ON_ONCE(chan->flags & (IEEE80211_CHAN_NO_IR |
                                                 IEEE80211_CHAN_DISABLED)))
                         goto unlock;
 
diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c
index 1eb66e26e49d..8ed97f76c3cf 100644
--- a/net/mac80211/sta_info.c
+++ b/net/mac80211/sta_info.c
@@ -266,9 +266,17 @@ struct sta_info *sta_info_get_by_idx(struct ieee80211_sub_if_data *sdata,
  */
 void sta_info_free(struct ieee80211_local *local, struct sta_info *sta)
 {
+        int i;
+
         if (sta->rate_ctrl)
                 rate_control_free_sta(sta);
 
+        if (sta->tx_lat) {
+                for (i = 0; i < IEEE80211_NUM_TIDS; i++)
+                        kfree(sta->tx_lat[i].bins);
+                kfree(sta->tx_lat);
+        }
+
         sta_dbg(sta->sdata, "Destroyed STA %pM\n", sta->sta.addr);
 
         kfree(sta);
@@ -333,6 +341,7 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
         struct ieee80211_local *local = sdata->local;
         struct sta_info *sta;
         struct timespec uptime;
+        struct ieee80211_tx_latency_bin_ranges *tx_latency;
         int i;
 
         sta = kzalloc(sizeof(*sta) + local->hw.sta_data_size, gfp);
@@ -410,6 +419,31 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
                 }
         }
 
+        rcu_read_lock();
+
+        tx_latency = rcu_dereference(local->tx_latency);
+        /* init stations Tx latency statistics && TID bins */
+        if (tx_latency)
+                sta->tx_lat = kzalloc(IEEE80211_NUM_TIDS *
+                                      sizeof(struct ieee80211_tx_latency_stat),
+                                      GFP_ATOMIC);
+
+        /*
+         * if Tx latency and bins are enabled and the previous allocation
+         * succeeded
+         */
+        if (tx_latency && tx_latency->n_ranges && sta->tx_lat)
+                for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
+                        /* size of bins is size of the ranges +1 */
+                        sta->tx_lat[i].bin_count =
+                                tx_latency->n_ranges + 1;
+                        sta->tx_lat[i].bins  = kcalloc(sta->tx_lat[i].bin_count,
+                                                       sizeof(u32),
+                                                       GFP_ATOMIC);
+                }
+
+        rcu_read_unlock();
+
         sta_dbg(sdata, "Allocated STA %pM\n", sta->sta.addr);
 
         return sta;
@@ -507,6 +541,7 @@ static int sta_info_insert_finish(struct sta_info *sta) __acquires(RCU)
 
         set_sta_flag(sta, WLAN_STA_INSERTED);
 
+        ieee80211_recalc_min_chandef(sdata);
         ieee80211_sta_debugfs_add(sta);
         rate_control_add_sta_debugfs(sta);
 
@@ -630,8 +665,8 @@ void sta_info_recalc_tim(struct sta_info *sta)
 #ifdef CONFIG_MAC80211_MESH
         } else if (ieee80211_vif_is_mesh(&sta->sdata->vif)) {
                 ps = &sta->sdata->u.mesh.ps;
-                /* TIM map only for PLID <= IEEE80211_MAX_AID */
-                id = le16_to_cpu(sta->plid) % IEEE80211_MAX_AID;
+                /* TIM map only for 1 <= PLID <= IEEE80211_MAX_AID */
+                id = sta->plid % (IEEE80211_MAX_AID + 1);
 #endif
         } else {
                 return;
@@ -869,6 +904,7 @@ int __must_check __sta_info_destroy(struct sta_info *sta)
 
         rate_control_remove_sta_debugfs(sta);
         ieee80211_sta_debugfs_remove(sta);
+        ieee80211_recalc_min_chandef(sdata);
 
         call_rcu(&sta->rcu_head, free_sta_rcu);
 
diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h
index 3ef06a26b9cb..0218caf5c14a 100644
--- a/net/mac80211/sta_info.h
+++ b/net/mac80211/sta_info.h
@@ -220,6 +220,25 @@ struct sta_ampdu_mlme {
         u8 dialog_token_allocator;
 };
 
+/*
+ * struct ieee80211_tx_latency_stat - Tx latency statistics
+ *
+ * Measures TX latency and jitter for a station per TID.
+ *
+ * @max: worst case latency
+ * @sum: sum of all latencies
+ * @counter: amount of Tx frames sent from interface
+ * @bins: each bin counts how many frames transmitted within a certain
+ * latency range. when disabled it is NULL.
+ * @bin_count: amount of bins.
+ */
+struct ieee80211_tx_latency_stat {
+        u32 max;
+        u32 sum;
+        u32 counter;
+        u32 *bins;
+        u32 bin_count;
+};
 
 /**
  * struct sta_info - STA information
@@ -231,8 +250,10 @@ struct sta_ampdu_mlme {
  * @hnext: hash table linked list pointer
  * @local: pointer to the global information
  * @sdata: virtual interface this station belongs to
- * @ptk: peer key negotiated with this station, if any
+ * @ptk: peer keys negotiated with this station, if any
+ * @ptk_idx: last installed peer key index
  * @gtk: group keys negotiated with this station, if any
+ * @gtk_idx: last installed group key index
  * @rate_ctrl: rate control algorithm reference
  * @rate_ctrl_priv: rate control private per-STA pointer
  * @last_tx_rate: rate used for last transmit, to report to userspace as
@@ -274,6 +295,7 @@ struct sta_ampdu_mlme {
  * @tid_seq: per-TID sequence numbers for sending to this STA
  * @ampdu_mlme: A-MPDU state machine state
  * @timer_to_tid: identity mapping to ID timers
+ * @tx_lat: Tx latency statistics
  * @llid: Local link ID
  * @plid: Peer link ID
  * @reason: Cancel reason on PLINK_HOLDING state
@@ -303,6 +325,7 @@ struct sta_ampdu_mlme {
  * @chain_signal_avg: signal average (per chain)
  * @known_smps_mode: the smps_mode the client thinks we are in. Relevant for
  *      AP only.
+ * @cipher_scheme: optional cipher scheme for this station
  */
 struct sta_info {
         /* General information, mostly static */
@@ -312,7 +335,9 @@ struct sta_info {
         struct ieee80211_local *local;
         struct ieee80211_sub_if_data *sdata;
         struct ieee80211_key __rcu *gtk[NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS];
-        struct ieee80211_key __rcu *ptk;
+        struct ieee80211_key __rcu *ptk[NUM_DEFAULT_KEYS];
+        u8 gtk_idx;
+        u8 ptk_idx;
         struct rate_control_ref *rate_ctrl;
         void *rate_ctrl_priv;
         spinlock_t lock;
@@ -380,14 +405,16 @@ struct sta_info {
         struct sta_ampdu_mlme ampdu_mlme;
         u8 timer_to_tid[IEEE80211_NUM_TIDS];
 
+        struct ieee80211_tx_latency_stat *tx_lat;
+
 #ifdef CONFIG_MAC80211_MESH
         /*
          * Mesh peer link attributes
          * TODO: move to a sub-structure that is referenced with pointer?
          */
-        __le16 llid;
-        __le16 plid;
-        __le16 reason;
+        u16 llid;
+        u16 plid;
+        u16 reason;
         u8 plink_retries;
         bool ignore_plink_timer;
         enum nl80211_plink_state plink_state;
@@ -414,6 +441,7 @@ struct sta_info {
         unsigned int beacon_loss_count;
 
         enum ieee80211_smps_mode known_smps_mode;
+        const struct ieee80211_cipher_scheme *cipher_scheme;
 
         /* keep last! */
         struct ieee80211_sta sta;
diff --git a/net/mac80211/status.c b/net/mac80211/status.c
index 52a152b01b06..1ee85c402439 100644
--- a/net/mac80211/status.c
+++ b/net/mac80211/status.c
@@ -11,6 +11,7 @@
 
 #include <linux/export.h>
 #include <linux/etherdevice.h>
+#include <linux/time.h>
 #include <net/mac80211.h>
 #include <asm/unaligned.h>
 #include "ieee80211_i.h"
@@ -463,6 +464,77 @@ static void ieee80211_report_used_skb(struct ieee80211_local *local,
 }
 
 /*
+ * Measure Tx frame completion and removal time for Tx latency statistics
+ * calculation. A single Tx frame latency should be measured from when it
+ * is entering the Kernel until we receive Tx complete confirmation indication
+ * and remove the skb.
+ */
+static void ieee80211_tx_latency_end_msrmnt(struct ieee80211_local *local,
+                                            struct sk_buff *skb,
+                                            struct sta_info *sta,
+                                            struct ieee80211_hdr *hdr)
+{
+        ktime_t skb_dprt;
+        struct timespec dprt_time;
+        u32 msrmnt;
+        u16 tid;
+        u8 *qc;
+        int i, bin_range_count, bin_count;
+        u32 *bin_ranges;
+        __le16 fc;
+        struct ieee80211_tx_latency_stat *tx_lat;
+        struct ieee80211_tx_latency_bin_ranges *tx_latency;
+        ktime_t skb_arv = skb->tstamp;
+
+        tx_latency = rcu_dereference(local->tx_latency);
+
+        /* assert Tx latency stats are enabled & frame arrived when enabled */
+        if (!tx_latency || !ktime_to_ns(skb_arv))
+                return;
+
+        fc = hdr->frame_control;
+
+        if (!ieee80211_is_data(fc)) /* make sure it is a data frame */
+                return;
+
+        /* get frame tid */
+        if (ieee80211_is_data_qos(hdr->frame_control)) {
+                qc = ieee80211_get_qos_ctl(hdr);
+                tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
+        } else {
+                tid = 0;
+        }
+
+        tx_lat = &sta->tx_lat[tid];
+
+        ktime_get_ts(&dprt_time); /* time stamp completion time */
+        skb_dprt = ktime_set(dprt_time.tv_sec, dprt_time.tv_nsec);
+        msrmnt = ktime_to_ms(ktime_sub(skb_dprt, skb_arv));
+
+        if (tx_lat->max < msrmnt) /* update stats */
+                tx_lat->max = msrmnt;
+        tx_lat->counter++;
+        tx_lat->sum += msrmnt;
+
+        if (!tx_lat->bins) /* bins not activated */
+                return;
+
+        /* count how many Tx frames transmitted with the appropriate latency */
+        bin_range_count = tx_latency->n_ranges;
+        bin_ranges = tx_latency->ranges;
+        bin_count = tx_lat->bin_count;
+
+        for (i = 0; i < bin_range_count; i++) {
+                if (msrmnt <= bin_ranges[i]) {
+                        tx_lat->bins[i]++;
+                        break;
+                }
+        }
+        if (i == bin_range_count) /* msrmnt is bigger than the biggest range */
+                tx_lat->bins[i]++;
+}
+
+/*
  * Use a static threshold for now, best value to be determined
  * by testing ...
  * Should it depend on:
@@ -620,6 +692,12 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
 
                 if (acked)
                         sta->last_ack_signal = info->status.ack_signal;
+
+                /*
+                 * Measure frame removal for tx latency
+                 * statistics calculation
+                 */
+                ieee80211_tx_latency_end_msrmnt(local, skb, sta, hdr);
         }
 
         rcu_read_unlock();
diff --git a/net/mac80211/trace.h b/net/mac80211/trace.h
index d4cee98533fd..e9ccf22f6dd9 100644
--- a/net/mac80211/trace.h
+++ b/net/mac80211/trace.h
@@ -41,14 +41,31 @@
 #define CHANDEF_PR_ARG  __entry->control_freq, __entry->chan_width,                     \
                         __entry->center_freq1, __entry->center_freq2
 
+#define MIN_CHANDEF_ENTRY                                                               \
+                        __field(u32, min_control_freq)                                  \
+                        __field(u32, min_chan_width)                                    \
+                        __field(u32, min_center_freq1)                                  \
+                        __field(u32, min_center_freq2)
+
+#define MIN_CHANDEF_ASSIGN(c)                                                           \
+                        __entry->min_control_freq = (c)->chan ? (c)->chan->center_freq : 0;     \
+                        __entry->min_chan_width = (c)->width;                           \
+                        __entry->min_center_freq1 = (c)->center_freq1;                  \
+                        __entry->min_center_freq2 = (c)->center_freq2;
+#define MIN_CHANDEF_PR_FMT      " min_control:%d MHz min_width:%d min_center: %d/%d MHz"
+#define MIN_CHANDEF_PR_ARG      __entry->min_control_freq, __entry->min_chan_width,     \
+                        __entry->min_center_freq1, __entry->min_center_freq2
+
 #define CHANCTX_ENTRY   CHANDEF_ENTRY                                                   \
+                        MIN_CHANDEF_ENTRY                                               \
                         __field(u8, rx_chains_static)                                   \
                         __field(u8, rx_chains_dynamic)
 #define CHANCTX_ASSIGN  CHANDEF_ASSIGN(&ctx->conf.def)                                  \
+                        MIN_CHANDEF_ASSIGN(&ctx->conf.min_def)                          \
                         __entry->rx_chains_static = ctx->conf.rx_chains_static;         \
                         __entry->rx_chains_dynamic = ctx->conf.rx_chains_dynamic
-#define CHANCTX_PR_FMT  CHANDEF_PR_FMT " chains:%d/%d"
-#define CHANCTX_PR_ARG  CHANDEF_PR_ARG,                                                 \
+#define CHANCTX_PR_FMT  CHANDEF_PR_FMT MIN_CHANDEF_PR_FMT " chains:%d/%d"
+#define CHANCTX_PR_ARG  CHANDEF_PR_ARG, MIN_CHANDEF_PR_ARG,                             \
                         __entry->rx_chains_static, __entry->rx_chains_dynamic
 
 
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index c558b246ef00..6d59e21cdb9f 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -19,6 +19,7 @@
 #include <linux/bitmap.h>
 #include <linux/rcupdate.h>
 #include <linux/export.h>
+#include <linux/time.h>
 #include <net/net_namespace.h>
 #include <net/ieee80211_radiotap.h>
 #include <net/cfg80211.h>
@@ -557,7 +558,8 @@ ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
 
         if (unlikely(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT))
                 tx->key = NULL;
-        else if (tx->sta && (key = rcu_dereference(tx->sta->ptk)))
+        else if (tx->sta &&
+                 (key = rcu_dereference(tx->sta->ptk[tx->sta->ptk_idx])))
                 tx->key = key;
         else if (ieee80211_is_mgmt(hdr->frame_control) &&
                  is_multicast_ether_addr(hdr->addr1) &&
@@ -840,15 +842,16 @@ static int ieee80211_fragment(struct ieee80211_tx_data *tx,
                 rem -= fraglen;
                 tmp = dev_alloc_skb(local->tx_headroom +
                                     frag_threshold +
-                                    IEEE80211_ENCRYPT_HEADROOM +
+                                    tx->sdata->encrypt_headroom +
                                     IEEE80211_ENCRYPT_TAILROOM);
                 if (!tmp)
                         return -ENOMEM;
 
                 __skb_queue_tail(&tx->skbs, tmp);
 
-                skb_reserve(tmp, local->tx_headroom +
-                                 IEEE80211_ENCRYPT_HEADROOM);
+                skb_reserve(tmp,
+                            local->tx_headroom + tx->sdata->encrypt_headroom);
+
                 /* copy control information */
                 memcpy(tmp->cb, skb->cb, sizeof(tmp->cb));
 
@@ -1485,7 +1488,7 @@ void ieee80211_xmit(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
 
         headroom = local->tx_headroom;
         if (may_encrypt)
-                headroom += IEEE80211_ENCRYPT_HEADROOM;
+                headroom += sdata->encrypt_headroom;
         headroom -= skb_headroom(skb);
         headroom = max_t(int, 0, headroom);
 
@@ -1724,8 +1727,7 @@ netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
          * radar detection by itself. We can do that later by adding a
          * monitor flag interfaces used for AP support.
          */
-        if ((chan->flags & (IEEE80211_CHAN_NO_IBSS | IEEE80211_CHAN_RADAR |
-                            IEEE80211_CHAN_PASSIVE_SCAN)))
+        if ((chan->flags & (IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_RADAR)))
                 goto fail_rcu;
 
         ieee80211_xmit(sdata, skb, chan->band);
@@ -1740,6 +1742,26 @@ fail:
         return NETDEV_TX_OK; /* meaning, we dealt with the skb */
 }
 
+/*
+ * Measure Tx frame arrival time for Tx latency statistics calculation
+ * A single Tx frame latency should be measured from when it is entering the
+ * Kernel until we receive Tx complete confirmation indication and the skb is
+ * freed.
+ */
+static void ieee80211_tx_latency_start_msrmnt(struct ieee80211_local *local,
+                                              struct sk_buff *skb)
+{
+        struct timespec skb_arv;
+        struct ieee80211_tx_latency_bin_ranges *tx_latency;
+
+        tx_latency = rcu_dereference(local->tx_latency);
+        if (!tx_latency)
+                return;
+
+        ktime_get_ts(&skb_arv);
+        skb->tstamp = ktime_set(skb_arv.tv_sec, skb_arv.tv_nsec);
+}
+
 /**
  * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
  * subinterfaces (wlan#, WDS, and VLAN interfaces)
@@ -1790,6 +1812,9 @@ netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
 
         rcu_read_lock();
 
+        /* Measure frame arrival for Tx latency statistics calculation */
+        ieee80211_tx_latency_start_msrmnt(local, skb);
+
         switch (sdata->vif.type) {
         case NL80211_IFTYPE_AP_VLAN:
                 sta = rcu_dereference(sdata->u.vlan.sta);
@@ -2109,7 +2134,7 @@ netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
          */
 
         if (head_need > 0 || skb_cloned(skb)) {
-                head_need += IEEE80211_ENCRYPT_HEADROOM;
+                head_need += sdata->encrypt_headroom;
                 head_need += local->tx_headroom;
                 head_need = max_t(int, 0, head_need);
                 if (ieee80211_skb_resize(sdata, skb, head_need, true)) {
diff --git a/net/mac80211/util.c b/net/mac80211/util.c
index 9f9b9bd3fd44..875e172c001c 100644
--- a/net/mac80211/util.c
+++ b/net/mac80211/util.c
@@ -1804,6 +1804,26 @@ void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
         mutex_unlock(&local->chanctx_mtx);
 }
 
+void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_local *local = sdata->local;
+        struct ieee80211_chanctx_conf *chanctx_conf;
+        struct ieee80211_chanctx *chanctx;
+
+        mutex_lock(&local->chanctx_mtx);
+
+        chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
+                                        lockdep_is_held(&local->chanctx_mtx));
+
+        if (WARN_ON_ONCE(!chanctx_conf))
+                goto unlock;
+
+        chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
+        ieee80211_recalc_chanctx_min_def(local, chanctx);
+ unlock:
+        mutex_unlock(&local->chanctx_mtx);
+}
+
 static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id)
 {
         int i;
@@ -2259,14 +2279,17 @@ u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
 void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
 {
         struct ieee80211_sub_if_data *sdata;
+        struct cfg80211_chan_def chandef;
 
         mutex_lock(&local->iflist_mtx);
         list_for_each_entry(sdata, &local->interfaces, list) {
                 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
 
                 if (sdata->wdev.cac_started) {
+                        chandef = sdata->vif.bss_conf.chandef;
                         ieee80211_vif_release_channel(sdata);
                         cfg80211_cac_event(sdata->dev,
+                                           &chandef,
                                            NL80211_RADAR_CAC_ABORTED,
                                            GFP_KERNEL);
                 }
@@ -2445,7 +2468,6 @@ int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
 
         if (ieee80211_vif_is_mesh(&sdata->vif)) {
                 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
-                __le16 pre_value;
 
                 skb_put(skb, 8);
                 *pos++ = WLAN_EID_CHAN_SWITCH_PARAM;            /* EID */
@@ -2457,11 +2479,78 @@ int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
                           WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
                 put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
                 pos += 2;
-                pre_value = cpu_to_le16(ifmsh->pre_value);
-                memcpy(pos, &pre_value, 2);             /* Precedence Value */
+                put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
                 pos += 2;
         }
 
         ieee80211_tx_skb(sdata, skb);
         return 0;
 }
+
+bool ieee80211_cs_valid(const struct ieee80211_cipher_scheme *cs)
+{
+        return !(cs == NULL || cs->cipher == 0 ||
+                 cs->hdr_len < cs->pn_len + cs->pn_off ||
+                 cs->hdr_len <= cs->key_idx_off ||
+                 cs->key_idx_shift > 7 ||
+                 cs->key_idx_mask == 0);
+}
+
+bool ieee80211_cs_list_valid(const struct ieee80211_cipher_scheme *cs, int n)
+{
+        int i;
+
+        /* Ensure we have enough iftype bitmap space for all iftype values */
+        WARN_ON((NUM_NL80211_IFTYPES / 8 + 1) > sizeof(cs[0].iftype));
+
+        for (i = 0; i < n; i++)
+                if (!ieee80211_cs_valid(&cs[i]))
+                        return false;
+
+        return true;
+}
+
+const struct ieee80211_cipher_scheme *
+ieee80211_cs_get(struct ieee80211_local *local, u32 cipher,
+                 enum nl80211_iftype iftype)
+{
+        const struct ieee80211_cipher_scheme *l = local->hw.cipher_schemes;
+        int n = local->hw.n_cipher_schemes;
+        int i;
+        const struct ieee80211_cipher_scheme *cs = NULL;
+
+        for (i = 0; i < n; i++) {
+                if (l[i].cipher == cipher) {
+                        cs = &l[i];
+                        break;
+                }
+        }
+
+        if (!cs || !(cs->iftype & BIT(iftype)))
+                return NULL;
+
+        return cs;
+}
+
+int ieee80211_cs_headroom(struct ieee80211_local *local,
+                          struct cfg80211_crypto_settings *crypto,
+                          enum nl80211_iftype iftype)
+{
+        const struct ieee80211_cipher_scheme *cs;
+        int headroom = IEEE80211_ENCRYPT_HEADROOM;
+        int i;
+
+        for (i = 0; i < crypto->n_ciphers_pairwise; i++) {
+                cs = ieee80211_cs_get(local, crypto->ciphers_pairwise[i],
+                                      iftype);
+
+                if (cs && headroom < cs->hdr_len)
+                        headroom = cs->hdr_len;
+        }
+
+        cs = ieee80211_cs_get(local, crypto->cipher_group, iftype);
+        if (cs && headroom < cs->hdr_len)
+                headroom = cs->hdr_len;
+
+        return headroom;
+}
diff --git a/net/mac80211/vht.c b/net/mac80211/vht.c
index de0112785aae..d75f35c6e1a0 100644
--- a/net/mac80211/vht.c
+++ b/net/mac80211/vht.c
@@ -182,16 +182,15 @@ ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
                          IEEE80211_VHT_CAP_SHORT_GI_160);
 
         /* remaining ones */
-        if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE) {
+        if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
                 vht_cap->cap |= cap_info &
                                 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
-                                 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MAX);
-        }
+                                 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK);
 
         if (own_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
                 vht_cap->cap |= cap_info &
                                 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
-                                 IEEE80211_VHT_CAP_BEAMFORMEE_STS_MAX);
+                                 IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK);
 
         if (own_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
                 vht_cap->cap |= cap_info &
diff --git a/net/mac80211/wpa.c b/net/mac80211/wpa.c
index d65728220763..7313d379c0d3 100644
--- a/net/mac80211/wpa.c
+++ b/net/mac80211/wpa.c
@@ -545,6 +545,106 @@ ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx)
         return RX_CONTINUE;
 }
 
+static ieee80211_tx_result
+ieee80211_crypto_cs_encrypt(struct ieee80211_tx_data *tx,
+                            struct sk_buff *skb)
+{
+        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+        struct ieee80211_key *key = tx->key;
+        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+        const struct ieee80211_cipher_scheme *cs = key->sta->cipher_scheme;
+        int hdrlen;
+        u8 *pos;
+
+        if (info->control.hw_key &&
+            !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) {
+                /* hwaccel has no need for preallocated head room */
+                return TX_CONTINUE;
+        }
+
+        if (unlikely(skb_headroom(skb) < cs->hdr_len &&
+                     pskb_expand_head(skb, cs->hdr_len, 0, GFP_ATOMIC)))
+                return TX_DROP;
+
+        hdrlen = ieee80211_hdrlen(hdr->frame_control);
+
+        pos = skb_push(skb, cs->hdr_len);
+        memmove(pos, pos + cs->hdr_len, hdrlen);
+        skb_set_network_header(skb, skb_network_offset(skb) + cs->hdr_len);
+
+        return TX_CONTINUE;
+}
+
+static inline int ieee80211_crypto_cs_pn_compare(u8 *pn1, u8 *pn2, int len)
+{
+        int i;
+
+        /* pn is little endian */
+        for (i = len - 1; i >= 0; i--) {
+                if (pn1[i] < pn2[i])
+                        return -1;
+                else if (pn1[i] > pn2[i])
+                        return 1;
+        }
+
+        return 0;
+}
+
+static ieee80211_rx_result
+ieee80211_crypto_cs_decrypt(struct ieee80211_rx_data *rx)
+{
+        struct ieee80211_key *key = rx->key;
+        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
+        const struct ieee80211_cipher_scheme *cs = NULL;
+        int hdrlen = ieee80211_hdrlen(hdr->frame_control);
+        struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
+        int data_len;
+        u8 *rx_pn;
+        u8 *skb_pn;
+        u8 qos_tid;
+
+        if (!rx->sta || !rx->sta->cipher_scheme ||
+            !(status->flag & RX_FLAG_DECRYPTED))
+                return RX_DROP_UNUSABLE;
+
+        if (!ieee80211_is_data(hdr->frame_control))
+                return RX_CONTINUE;
+
+        cs = rx->sta->cipher_scheme;
+
+        data_len = rx->skb->len - hdrlen - cs->hdr_len;
+
+        if (data_len < 0)
+                return RX_DROP_UNUSABLE;
+
+        if (ieee80211_is_data_qos(hdr->frame_control))
+                qos_tid = *ieee80211_get_qos_ctl(hdr) &
+                                IEEE80211_QOS_CTL_TID_MASK;
+        else
+                qos_tid = 0;
+
+        if (skb_linearize(rx->skb))
+                return RX_DROP_UNUSABLE;
+
+        hdr = (struct ieee80211_hdr *)rx->skb->data;
+
+        rx_pn = key->u.gen.rx_pn[qos_tid];
+        skb_pn = rx->skb->data + hdrlen + cs->pn_off;
+
+        if (ieee80211_crypto_cs_pn_compare(skb_pn, rx_pn, cs->pn_len) <= 0)
+                return RX_DROP_UNUSABLE;
+
+        memcpy(rx_pn, skb_pn, cs->pn_len);
+
+        /* remove security header and MIC */
+        if (pskb_trim(rx->skb, rx->skb->len - cs->mic_len))
+                return RX_DROP_UNUSABLE;
+
+        memmove(rx->skb->data + cs->hdr_len, rx->skb->data, hdrlen);
+        skb_pull(rx->skb, cs->hdr_len);
+
+        return RX_CONTINUE;
+}
 
 static void bip_aad(struct sk_buff *skb, u8 *aad)
 {
@@ -685,6 +785,7 @@ ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data *tx)
 {
         struct sk_buff *skb;
         struct ieee80211_tx_info *info = NULL;
+        ieee80211_tx_result res;
 
         skb_queue_walk(&tx->skbs, skb) {
                 info  = IEEE80211_SKB_CB(skb);
@@ -692,9 +793,24 @@ ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data *tx)
                 /* handle hw-only algorithm */
                 if (!info->control.hw_key)
                         return TX_DROP;
+
+                if (tx->key->sta->cipher_scheme) {
+                        res = ieee80211_crypto_cs_encrypt(tx, skb);
+                        if (res != TX_CONTINUE)
+                                return res;
+                }
         }
 
         ieee80211_tx_set_protected(tx);
 
         return TX_CONTINUE;
 }
+
+ieee80211_rx_result
+ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data *rx)
+{
+        if (rx->sta->cipher_scheme)
+                return ieee80211_crypto_cs_decrypt(rx);
+
+        return RX_DROP_UNUSABLE;
+}
diff --git a/net/mac80211/wpa.h b/net/mac80211/wpa.h
index 07e33f899c71..62e5a12dfe0a 100644
--- a/net/mac80211/wpa.h
+++ b/net/mac80211/wpa.h
@@ -34,5 +34,7 @@ ieee80211_rx_result
 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx);
 ieee80211_tx_result
 ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data *tx);
+ieee80211_rx_result
+ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data *rx);
 
 #endif /* WPA_H */
diff --git a/net/wireless/chan.c b/net/wireless/chan.c
index 9b8cc877eb19..78559b5bbd1f 100644
--- a/net/wireless/chan.c
+++ b/net/wireless/chan.c
@@ -277,6 +277,32 @@ void cfg80211_set_dfs_state(struct wiphy *wiphy,
                                      width, dfs_state);
 }
 
+static u32 cfg80211_get_start_freq(u32 center_freq,
+                                   u32 bandwidth)
+{
+        u32 start_freq;
+
+        if (bandwidth <= 20)
+                start_freq = center_freq;
+        else
+                start_freq = center_freq - bandwidth/2 + 10;
+
+        return start_freq;
+}
+
+static u32 cfg80211_get_end_freq(u32 center_freq,
+                                 u32 bandwidth)
+{
+        u32 end_freq;
+
+        if (bandwidth <= 20)
+                end_freq = center_freq;
+        else
+                end_freq = center_freq + bandwidth/2 - 10;
+
+        return end_freq;
+}
+
 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
                                             u32 center_freq,
                                             u32 bandwidth)
@@ -284,13 +310,8 @@ static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
         struct ieee80211_channel *c;
         u32 freq, start_freq, end_freq;
 
-        if (bandwidth <= 20) {
-                start_freq = center_freq;
-                end_freq = center_freq;
-        } else {
-                start_freq = center_freq - bandwidth/2 + 10;
-                end_freq = center_freq + bandwidth/2 - 10;
-        }
+        start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
+        end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 
         for (freq = start_freq; freq <= end_freq; freq += 20) {
                 c = ieee80211_get_channel(wiphy, freq);
@@ -330,33 +351,159 @@ int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
 }
 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 
-static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
-                                        u32 center_freq, u32 bandwidth,
-                                        u32 prohibited_flags)
+static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
+                                         u32 center_freq,
+                                         u32 bandwidth)
 {
         struct ieee80211_channel *c;
         u32 freq, start_freq, end_freq;
+        int count = 0;
 
-        if (bandwidth <= 20) {
-                start_freq = center_freq;
-                end_freq = center_freq;
-        } else {
-                start_freq = center_freq - bandwidth/2 + 10;
-                end_freq = center_freq + bandwidth/2 - 10;
+        start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
+        end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
+
+        /*
+         * Check entire range of channels for the bandwidth.
+         * Check all channels are DFS channels (DFS_USABLE or
+         * DFS_AVAILABLE). Return number of usable channels
+         * (require CAC). Allow DFS and non-DFS channel mix.
+         */
+        for (freq = start_freq; freq <= end_freq; freq += 20) {
+                c = ieee80211_get_channel(wiphy, freq);
+                if (!c)
+                        return -EINVAL;
+
+                if (c->flags & IEEE80211_CHAN_DISABLED)
+                        return -EINVAL;
+
+                if (c->flags & IEEE80211_CHAN_RADAR) {
+                        if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
+                                return -EINVAL;
+
+                        if (c->dfs_state == NL80211_DFS_USABLE)
+                                count++;
+                }
         }
 
+        return count;
+}
+
+bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
+                                 const struct cfg80211_chan_def *chandef)
+{
+        int width;
+        int r1, r2 = 0;
+
+        if (WARN_ON(!cfg80211_chandef_valid(chandef)))
+                return false;
+
+        width = cfg80211_chandef_get_width(chandef);
+        if (width < 0)
+                return false;
+
+        r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
+                                          width);
+
+        if (r1 < 0)
+                return false;
+
+        switch (chandef->width) {
+        case NL80211_CHAN_WIDTH_80P80:
+                WARN_ON(!chandef->center_freq2);
+                r2 = cfg80211_get_chans_dfs_usable(wiphy,
+                                                   chandef->center_freq2,
+                                                   width);
+                if (r2 < 0)
+                        return false;
+                break;
+        default:
+                WARN_ON(chandef->center_freq2);
+                break;
+        }
+
+        return (r1 + r2 > 0);
+}
+
+
+static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
+                                             u32 center_freq,
+                                             u32 bandwidth)
+{
+        struct ieee80211_channel *c;
+        u32 freq, start_freq, end_freq;
+
+        start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
+        end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
+
+        /*
+         * Check entire range of channels for the bandwidth.
+         * If any channel in between is disabled or has not
+         * had gone through CAC return false
+         */
         for (freq = start_freq; freq <= end_freq; freq += 20) {
                 c = ieee80211_get_channel(wiphy, freq);
                 if (!c)
                         return false;
 
-                /* check for radar flags */
-                if ((prohibited_flags & c->flags & IEEE80211_CHAN_RADAR) &&
+                if (c->flags & IEEE80211_CHAN_DISABLED)
+                        return false;
+
+                if ((c->flags & IEEE80211_CHAN_RADAR)  &&
                     (c->dfs_state != NL80211_DFS_AVAILABLE))
                         return false;
+        }
+
+        return true;
+}
+
+static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
+                                const struct cfg80211_chan_def *chandef)
+{
+        int width;
+        int r;
+
+        if (WARN_ON(!cfg80211_chandef_valid(chandef)))
+                return false;
+
+        width = cfg80211_chandef_get_width(chandef);
+        if (width < 0)
+                return false;
+
+        r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
+                                             width);
+
+        /* If any of channels unavailable for cf1 just return */
+        if (!r)
+                return r;
+
+        switch (chandef->width) {
+        case NL80211_CHAN_WIDTH_80P80:
+                WARN_ON(!chandef->center_freq2);
+                r = cfg80211_get_chans_dfs_available(wiphy,
+                                                     chandef->center_freq2,
+                                                     width);
+        default:
+                WARN_ON(chandef->center_freq2);
+                break;
+        }
+
+        return r;
+}
 
-                /* check for the other flags */
-                if (c->flags & prohibited_flags & ~IEEE80211_CHAN_RADAR)
+
+static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
+                                        u32 center_freq, u32 bandwidth,
+                                        u32 prohibited_flags)
+{
+        struct ieee80211_channel *c;
+        u32 freq, start_freq, end_freq;
+
+        start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
+        end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
+
+        for (freq = start_freq; freq <= end_freq; freq += 20) {
+                c = ieee80211_get_channel(wiphy, freq);
+                if (!c || c->flags & prohibited_flags)
                         return false;
         }
 
@@ -462,14 +609,19 @@ bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
                              struct cfg80211_chan_def *chandef)
 {
         bool res;
+        u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
+                               IEEE80211_CHAN_NO_IR |
+                               IEEE80211_CHAN_RADAR;
 
         trace_cfg80211_reg_can_beacon(wiphy, chandef);
 
-        res = cfg80211_chandef_usable(wiphy, chandef,
-                                      IEEE80211_CHAN_DISABLED |
-                                      IEEE80211_CHAN_PASSIVE_SCAN |
-                                      IEEE80211_CHAN_NO_IBSS |
-                                      IEEE80211_CHAN_RADAR);
+        if (cfg80211_chandef_dfs_required(wiphy, chandef) > 0 &&
+            cfg80211_chandef_dfs_available(wiphy, chandef)) {
+                /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
+                prohibited_flags = IEEE80211_CHAN_DISABLED;
+        }
+
+        res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
 
         trace_cfg80211_return_bool(res);
         return res;
@@ -510,6 +662,7 @@ cfg80211_get_chan_state(struct wireless_dev *wdev,
                                   : CHAN_MODE_EXCLUSIVE;
                         return;
                 }
+                break;
         case NL80211_IFTYPE_STATION:
         case NL80211_IFTYPE_P2P_CLIENT:
                 if (wdev->current_bss) {
diff --git a/net/wireless/core.c b/net/wireless/core.c
index 52b865fb7351..06db6eb5258a 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -357,8 +357,6 @@ struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
         rdev->wiphy.rts_threshold = (u32) -1;
         rdev->wiphy.coverage_class = 0;
 
-        rdev->wiphy.features = NL80211_FEATURE_SCAN_FLUSH;
-
         return &rdev->wiphy;
 }
 EXPORT_SYMBOL(wiphy_new);
@@ -575,6 +573,8 @@ int wiphy_register(struct wiphy *wiphy)
         /* check and set up bitrates */
         ieee80211_set_bitrate_flags(wiphy);
 
+        rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
+
         rtnl_lock();
         res = device_add(&rdev->wiphy.dev);
         if (res) {
@@ -595,7 +595,7 @@ int wiphy_register(struct wiphy *wiphy)
         if (IS_ERR(rdev->wiphy.debugfsdir))
                 rdev->wiphy.debugfsdir = NULL;
 
-        if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
+        if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
                 struct regulatory_request request;
 
                 request.wiphy_idx = get_wiphy_idx(wiphy);
diff --git a/net/wireless/core.h b/net/wireless/core.h
index af10e59af2d8..0a277c33bb02 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -317,9 +317,8 @@ void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlpid);
 void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev);
 int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
                           struct wireless_dev *wdev,
-                          struct ieee80211_channel *chan, bool offchan,
-                          unsigned int wait, const u8 *buf, size_t len,
-                          bool no_cck, bool dont_wait_for_ack, u64 *cookie);
+                          struct cfg80211_mgmt_tx_params *params,
+                          u64 *cookie);
 void cfg80211_oper_and_ht_capa(struct ieee80211_ht_cap *ht_capa,
                                const struct ieee80211_ht_cap *ht_capa_mask);
 void cfg80211_oper_and_vht_capa(struct ieee80211_vht_cap *vht_capa,
@@ -382,6 +381,19 @@ int cfg80211_can_use_iftype_chan(struct cfg80211_registered_device *rdev,
                                  enum cfg80211_chan_mode chanmode,
                                  u8 radar_detect);
 
+/**
+ * cfg80211_chandef_dfs_usable - checks if chandef is DFS usable
+ * @wiphy: the wiphy to validate against
+ * @chandef: the channel definition to check
+ *
+ * Checks if chandef is usable and we can/need start CAC on such channel.
+ *
+ * Return: Return true if all channels available and at least
+ *         one channel require CAC (NL80211_DFS_USABLE)
+ */
+bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
+                                 const struct cfg80211_chan_def *chandef);
+
 void cfg80211_set_dfs_state(struct wiphy *wiphy,
                             const struct cfg80211_chan_def *chandef,
                             enum nl80211_dfs_state dfs_state);
diff --git a/net/wireless/genregdb.awk b/net/wireless/genregdb.awk
index 42ed274e81f4..9a8217d2a908 100644
--- a/net/wireless/genregdb.awk
+++ b/net/wireless/genregdb.awk
@@ -33,15 +33,7 @@ BEGIN {
         regdb = "const struct ieee80211_regdomain *reg_regdb[] = {\n"
 }
 
-/^[ \t]*#/ {
-        # Ignore
-}
-
-!active && /^[ \t]*$/ {
-        # Ignore
-}
-
-!active && /country/ {
+function parse_country_head() {
         country=$2
         sub(/:/, "", country)
         printf "static const struct ieee80211_regdomain regdom_%s = {\n", country
@@ -57,7 +49,8 @@ BEGIN {
         regdb = regdb "\t&regdom_" country ",\n"
 }
 
-active && /^[ \t]*\(/ {
+function parse_reg_rule()
+{
         start = $1
         sub(/\(/, "", start)
         end = $3
@@ -107,17 +100,21 @@ active && /^[ \t]*\(/ {
                 } else if (flagarray[arg] == "PTMP-ONLY") {
                         flags = flags "\n\t\t\tNL80211_RRF_PTMP_ONLY | "
                 } else if (flagarray[arg] == "PASSIVE-SCAN") {
-                        flags = flags "\n\t\t\tNL80211_RRF_PASSIVE_SCAN | "
+                        flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
                 } else if (flagarray[arg] == "NO-IBSS") {
-                        flags = flags "\n\t\t\tNL80211_RRF_NO_IBSS | "
+                        flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
+                } else if (flagarray[arg] == "NO-IR") {
+                        flags = flags "\n\t\t\tNL80211_RRF_NO_IR | "
                 }
+
         }
         flags = flags "0"
         printf "\t\tREG_RULE(%d, %d, %d, %d, %d, %s),\n", start, end, bw, gain, power, flags
         rules++
 }
 
-active && /^[ \t]*$/ {
+function print_tail_country()
+{
         active = 0
         printf "\t},\n"
         printf "\t.n_reg_rules = %d\n", rules
@@ -125,7 +122,29 @@ active && /^[ \t]*$/ {
         rules = 0;
 }
 
+/^[ \t]*#/ {
+        # Ignore
+}
+
+!active && /^[ \t]*$/ {
+        # Ignore
+}
+
+!active && /country/ {
+        parse_country_head()
+}
+
+active && /^[ \t]*\(/ {
+        parse_reg_rule()
+}
+
+active && /^[ \t]*$/ {
+        print_tail_country()
+}
+
 END {
+        if (active)
+                print_tail_country()
         print regdb "};"
         print ""
         print "int reg_regdb_size = ARRAY_SIZE(reg_regdb);"
diff --git a/net/wireless/ibss.c b/net/wireless/ibss.c
index 89737ee2669a..730147ed8e65 100644
--- a/net/wireless/ibss.c
+++ b/net/wireless/ibss.c
@@ -274,7 +274,7 @@ int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
 
                         for (i = 0; i < sband->n_channels; i++) {
                                 chan = &sband->channels[i];
-                                if (chan->flags & IEEE80211_CHAN_NO_IBSS)
+                                if (chan->flags & IEEE80211_CHAN_NO_IR)
                                         continue;
                                 if (chan->flags & IEEE80211_CHAN_DISABLED)
                                         continue;
@@ -346,7 +346,7 @@ int cfg80211_ibss_wext_siwfreq(struct net_device *dev,
                 chan = ieee80211_get_channel(wdev->wiphy, freq);
                 if (!chan)
                         return -EINVAL;
-                if (chan->flags & IEEE80211_CHAN_NO_IBSS ||
+                if (chan->flags & IEEE80211_CHAN_NO_IR ||
                     chan->flags & IEEE80211_CHAN_DISABLED)
                         return -EINVAL;
         }
diff --git a/net/wireless/mesh.c b/net/wireless/mesh.c
index 0553fd4d85ae..b0e1869de7de 100644
--- a/net/wireless/mesh.c
+++ b/net/wireless/mesh.c
@@ -141,8 +141,7 @@ int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
 
                         for (i = 0; i < sband->n_channels; i++) {
                                 chan = &sband->channels[i];
-                                if (chan->flags & (IEEE80211_CHAN_NO_IBSS |
-                                                   IEEE80211_CHAN_PASSIVE_SCAN |
+                                if (chan->flags & (IEEE80211_CHAN_NO_IR |
                                                    IEEE80211_CHAN_DISABLED |
                                                    IEEE80211_CHAN_RADAR))
                                         continue;
diff --git a/net/wireless/mlme.c b/net/wireless/mlme.c
index 6a6b1c8e907d..52cca05044a8 100644
--- a/net/wireless/mlme.c
+++ b/net/wireless/mlme.c
@@ -520,9 +520,7 @@ void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev)
 
 int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
                           struct wireless_dev *wdev,
-                          struct ieee80211_channel *chan, bool offchan,
-                          unsigned int wait, const u8 *buf, size_t len,
-                          bool no_cck, bool dont_wait_for_ack, u64 *cookie)
+                          struct cfg80211_mgmt_tx_params *params, u64 *cookie)
 {
         const struct ieee80211_mgmt *mgmt;
         u16 stype;
@@ -533,10 +531,10 @@ int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
         if (!rdev->ops->mgmt_tx)
                 return -EOPNOTSUPP;
 
-        if (len < 24 + 1)
+        if (params->len < 24 + 1)
                 return -EINVAL;
 
-        mgmt = (const struct ieee80211_mgmt *) buf;
+        mgmt = (const struct ieee80211_mgmt *)params->buf;
 
         if (!ieee80211_is_mgmt(mgmt->frame_control))
                 return -EINVAL;
@@ -615,9 +613,7 @@ int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
                 return -EINVAL;
 
         /* Transmit the Action frame as requested by user space */
-        return rdev_mgmt_tx(rdev, wdev, chan, offchan,
-                            wait, buf, len, no_cck, dont_wait_for_ack,
-                            cookie);
+        return rdev_mgmt_tx(rdev, wdev, params, cookie);
 }
 
 bool cfg80211_rx_mgmt(struct wireless_dev *wdev, int freq, int sig_mbm,
@@ -763,12 +759,12 @@ void cfg80211_radar_event(struct wiphy *wiphy,
 EXPORT_SYMBOL(cfg80211_radar_event);
 
 void cfg80211_cac_event(struct net_device *netdev,
+                        const struct cfg80211_chan_def *chandef,
                         enum nl80211_radar_event event, gfp_t gfp)
 {
         struct wireless_dev *wdev = netdev->ieee80211_ptr;
         struct wiphy *wiphy = wdev->wiphy;
         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
-        struct cfg80211_chan_def chandef;
         unsigned long timeout;
 
         trace_cfg80211_cac_event(netdev, event);
@@ -779,14 +775,12 @@ void cfg80211_cac_event(struct net_device *netdev,
         if (WARN_ON(!wdev->channel))
                 return;
 
-        cfg80211_chandef_create(&chandef, wdev->channel, NL80211_CHAN_NO_HT);
-
         switch (event) {
         case NL80211_RADAR_CAC_FINISHED:
                 timeout = wdev->cac_start_time +
                           msecs_to_jiffies(IEEE80211_DFS_MIN_CAC_TIME_MS);
                 WARN_ON(!time_after_eq(jiffies, timeout));
-                cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_AVAILABLE);
+                cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_AVAILABLE);
                 break;
         case NL80211_RADAR_CAC_ABORTED:
                 break;
@@ -796,6 +790,6 @@ void cfg80211_cac_event(struct net_device *netdev,
         }
         wdev->cac_started = false;
 
-        nl80211_radar_notify(rdev, &chandef, event, netdev, gfp);
+        nl80211_radar_notify(rdev, chandef, event, netdev, gfp);
 }
 EXPORT_SYMBOL(cfg80211_cac_event);
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 138dc3bb8b67..a693f86e5970 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -564,12 +564,12 @@ static int nl80211_msg_put_channel(struct sk_buff *msg,
         if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
             nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
                 goto nla_put_failure;
-        if ((chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
-            nla_put_flag(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN))
-                goto nla_put_failure;
-        if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
-            nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IBSS))
-                goto nla_put_failure;
+        if (chan->flags & IEEE80211_CHAN_NO_IR) {
+                if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
+                        goto nla_put_failure;
+                if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
+                        goto nla_put_failure;
+        }
         if (chan->flags & IEEE80211_CHAN_RADAR) {
                 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
                         goto nla_put_failure;
@@ -1247,10 +1247,6 @@ static int nl80211_send_wiphy(struct cfg80211_registered_device *dev,
                 if ((dev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
                     nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
                         goto nla_put_failure;
-                if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
-                    nla_put_flag(msg, WIPHY_FLAG_SUPPORTS_5_10_MHZ))
-                        goto nla_put_failure;
-
                 state->split_start++;
                 if (state->split)
                         break;
@@ -1579,6 +1575,11 @@ static int nl80211_send_wiphy(struct cfg80211_registered_device *dev,
                 if (nl80211_send_coalesce(msg, dev))
                         goto nla_put_failure;
 
+                if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
+                    (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
+                     nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
+                        goto nla_put_failure;
+
                 /* done */
                 state->split_start = 0;
                 break;
@@ -2187,7 +2188,7 @@ static inline u64 wdev_id(struct wireless_dev *wdev)
 }
 
 static int nl80211_send_chandef(struct sk_buff *msg,
-                                 struct cfg80211_chan_def *chandef)
+                                const struct cfg80211_chan_def *chandef)
 {
         WARN_ON(!cfg80211_chandef_valid(chandef));
 
@@ -3236,6 +3237,7 @@ static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
                         return PTR_ERR(params.acl);
         }
 
+        wdev_lock(wdev);
         err = rdev_start_ap(rdev, dev, &params);
         if (!err) {
                 wdev->preset_chandef = params.chandef;
@@ -3244,6 +3246,7 @@ static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
                 wdev->ssid_len = params.ssid_len;
                 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
         }
+        wdev_unlock(wdev);
 
         kfree(params.acl);
 
@@ -3272,7 +3275,11 @@ static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
         if (err)
                 return err;
 
-        return rdev_change_beacon(rdev, dev, &params);
+        wdev_lock(wdev);
+        err = rdev_change_beacon(rdev, dev, &params);
+        wdev_unlock(wdev);
+
+        return err;
 }
 
 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
@@ -4478,7 +4485,9 @@ static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
 {
         struct cfg80211_registered_device *rdev = info->user_ptr[0];
         struct net_device *dev = info->user_ptr[1];
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
         struct bss_parameters params;
+        int err;
 
         memset(&params, 0, sizeof(params));
         /* default to not changing parameters */
@@ -4544,7 +4553,11 @@ static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
             dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
                 return -EOPNOTSUPP;
 
-        return rdev_change_bss(rdev, dev, &params);
+        wdev_lock(wdev);
+        err = rdev_change_bss(rdev, dev, &params);
+        wdev_unlock(wdev);
+
+        return err;
 }
 
 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
@@ -5098,7 +5111,7 @@ static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
         char *alpha2 = NULL;
         int rem_reg_rules = 0, r = 0;
         u32 num_rules = 0, rule_idx = 0, size_of_regd;
-        u8 dfs_region = 0;
+        enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
         struct ieee80211_regdomain *rd = NULL;
 
         if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
@@ -5119,6 +5132,9 @@ static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
                         return -EINVAL;
         }
 
+        if (!reg_is_valid_request(alpha2))
+                return -EINVAL;
+
         size_of_regd = sizeof(struct ieee80211_regdomain) +
                        num_rules * sizeof(struct ieee80211_reg_rule);
 
@@ -5365,10 +5381,8 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
         if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
                 request->flags = nla_get_u32(
                         info->attrs[NL80211_ATTR_SCAN_FLAGS]);
-                if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
-                     !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
-                    ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
-                     !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
+                if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
+                    !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
                         err = -EOPNOTSUPP;
                         goto out_free;
                 }
@@ -5608,10 +5622,8 @@ static int nl80211_start_sched_scan(struct sk_buff *skb,
         if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
                 request->flags = nla_get_u32(
                         info->attrs[NL80211_ATTR_SCAN_FLAGS]);
-                if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
-                     !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
-                    ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
-                     !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
+                if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
+                    !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
                         err = -EOPNOTSUPP;
                         goto out_free;
                 }
@@ -5674,7 +5686,7 @@ static int nl80211_start_radar_detection(struct sk_buff *skb,
         if (err == 0)
                 return -EINVAL;
 
-        if (chandef.chan->dfs_state != NL80211_DFS_USABLE)
+        if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
                 return -EINVAL;
 
         if (!rdev->ops->start_radar_detection)
@@ -5814,7 +5826,11 @@ skip_beacons:
         if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
                 params.block_tx = true;
 
-        return rdev_channel_switch(rdev, dev, &params);
+        wdev_lock(wdev);
+        err = rdev_channel_switch(rdev, dev, &params);
+        wdev_unlock(wdev);
+
+        return err;
 }
 
 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
@@ -7447,10 +7463,10 @@ static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
         void *hdr = NULL;
         u64 cookie;
         struct sk_buff *msg = NULL;
-        unsigned int wait = 0;
-        bool offchan, no_cck, dont_wait_for_ack;
-
-        dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
+        struct cfg80211_mgmt_tx_params params = {
+                .dont_wait_for_ack =
+                        info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
+        };
 
         if (!info->attrs[NL80211_ATTR_FRAME])
                 return -EINVAL;
@@ -7477,24 +7493,24 @@ static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
         if (info->attrs[NL80211_ATTR_DURATION]) {
                 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
                         return -EINVAL;
-                wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
+                params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
 
                 /*
                  * We should wait on the channel for at least a minimum amount
                  * of time (10ms) but no longer than the driver supports.
                  */
-                if (wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
-                    wait > rdev->wiphy.max_remain_on_channel_duration)
+                if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
+                    params.wait > rdev->wiphy.max_remain_on_channel_duration)
                         return -EINVAL;
 
         }
 
-        offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
+        params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
 
-        if (offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
+        if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
                 return -EINVAL;
 
-        no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
+        params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
 
         /* get the channel if any has been specified, otherwise pass NULL to
          * the driver. The latter will use the current one
@@ -7506,10 +7522,10 @@ static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
                         return err;
         }
 
-        if (!chandef.chan && offchan)
+        if (!chandef.chan && params.offchan)
                 return -EINVAL;
 
-        if (!dont_wait_for_ack) {
+        if (!params.dont_wait_for_ack) {
                 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
                 if (!msg)
                         return -ENOMEM;
@@ -7522,10 +7538,10 @@ static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
                 }
         }
 
-        err = cfg80211_mlme_mgmt_tx(rdev, wdev, chandef.chan, offchan, wait,
-                                    nla_data(info->attrs[NL80211_ATTR_FRAME]),
-                                    nla_len(info->attrs[NL80211_ATTR_FRAME]),
-                                    no_cck, dont_wait_for_ack, &cookie);
+        params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
+        params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
+        params.chan = chandef.chan;
+        err = cfg80211_mlme_mgmt_tx(rdev, wdev, &params, &cookie);
         if (err)
                 goto free_msg;
 
@@ -10810,21 +10826,18 @@ void cfg80211_ch_switch_notify(struct net_device *dev,
         struct wiphy *wiphy = wdev->wiphy;
         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
 
-        trace_cfg80211_ch_switch_notify(dev, chandef);
+        ASSERT_WDEV_LOCK(wdev);
 
-        wdev_lock(wdev);
+        trace_cfg80211_ch_switch_notify(dev, chandef);
 
         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
                     wdev->iftype != NL80211_IFTYPE_P2P_GO &&
                     wdev->iftype != NL80211_IFTYPE_ADHOC &&
                     wdev->iftype != NL80211_IFTYPE_MESH_POINT))
-                goto out;
+                return;
 
         wdev->channel = chandef->chan;
         nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL);
-out:
-        wdev_unlock(wdev);
-        return;
 }
 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
 
@@ -10883,7 +10896,7 @@ EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
 
 void
 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
-                     struct cfg80211_chan_def *chandef,
+                     const struct cfg80211_chan_def *chandef,
                      enum nl80211_radar_event event,
                      struct net_device *netdev, gfp_t gfp)
 {
diff --git a/net/wireless/nl80211.h b/net/wireless/nl80211.h
index 2c0f2b3c07cb..b1b231324e10 100644
--- a/net/wireless/nl80211.h
+++ b/net/wireless/nl80211.h
@@ -70,7 +70,7 @@ int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
 
 void
 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
-                     struct cfg80211_chan_def *chandef,
+                     const struct cfg80211_chan_def *chandef,
                      enum nl80211_radar_event event,
                      struct net_device *netdev, gfp_t gfp);
 
diff --git a/net/wireless/rdev-ops.h b/net/wireless/rdev-ops.h
index 37ce9fdfe934..a6c03ab14a0d 100644
--- a/net/wireless/rdev-ops.h
+++ b/net/wireless/rdev-ops.h
@@ -624,16 +624,12 @@ rdev_cancel_remain_on_channel(struct cfg80211_registered_device *rdev,
 
 static inline int rdev_mgmt_tx(struct cfg80211_registered_device *rdev,
                                struct wireless_dev *wdev,
-                               struct ieee80211_channel *chan, bool offchan,
-                               unsigned int wait, const u8 *buf, size_t len,
-                               bool no_cck, bool dont_wait_for_ack, u64 *cookie)
+                               struct cfg80211_mgmt_tx_params *params,
+                               u64 *cookie)
 {
         int ret;
-        trace_rdev_mgmt_tx(&rdev->wiphy, wdev, chan, offchan,
-                           wait, no_cck, dont_wait_for_ack);
-        ret = rdev->ops->mgmt_tx(&rdev->wiphy, wdev, chan, offchan,
-                                  wait, buf, len, no_cck,
-                                  dont_wait_for_ack, cookie);
+        trace_rdev_mgmt_tx(&rdev->wiphy, wdev, params);
+        ret = rdev->ops->mgmt_tx(&rdev->wiphy, wdev, params, cookie);
         trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie);
         return ret;
 }
diff --git a/net/wireless/reg.c b/net/wireless/reg.c
index 7da67fd0b418..ec54e1aac8e2 100644
--- a/net/wireless/reg.c
+++ b/net/wireless/reg.c
@@ -120,6 +120,21 @@ static const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
         return rtnl_dereference(wiphy->regd);
 }
 
+static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region)
+{
+        switch (dfs_region) {
+        case NL80211_DFS_UNSET:
+                return "unset";
+        case NL80211_DFS_FCC:
+                return "FCC";
+        case NL80211_DFS_ETSI:
+                return "ETSI";
+        case NL80211_DFS_JP:
+                return "JP";
+        }
+        return "Unknown";
+}
+
 static void rcu_free_regdom(const struct ieee80211_regdomain *r)
 {
         if (!r)
@@ -163,35 +178,29 @@ static const struct ieee80211_regdomain world_regdom = {
                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
                 /* IEEE 802.11b/g, channels 12..13. */
                 REG_RULE(2467-10, 2472+10, 40, 6, 20,
-                        NL80211_RRF_PASSIVE_SCAN |
-                        NL80211_RRF_NO_IBSS),
+                        NL80211_RRF_NO_IR),
                 /* IEEE 802.11 channel 14 - Only JP enables
                  * this and for 802.11b only */
                 REG_RULE(2484-10, 2484+10, 20, 6, 20,
-                        NL80211_RRF_PASSIVE_SCAN |
-                        NL80211_RRF_NO_IBSS |
+                        NL80211_RRF_NO_IR |
                         NL80211_RRF_NO_OFDM),
                 /* IEEE 802.11a, channel 36..48 */
                 REG_RULE(5180-10, 5240+10, 160, 6, 20,
-                        NL80211_RRF_PASSIVE_SCAN |
-                        NL80211_RRF_NO_IBSS),
+                        NL80211_RRF_NO_IR),
 
                 /* IEEE 802.11a, channel 52..64 - DFS required */
                 REG_RULE(5260-10, 5320+10, 160, 6, 20,
-                        NL80211_RRF_PASSIVE_SCAN |
-                        NL80211_RRF_NO_IBSS |
+                        NL80211_RRF_NO_IR |
                         NL80211_RRF_DFS),
 
                 /* IEEE 802.11a, channel 100..144 - DFS required */
                 REG_RULE(5500-10, 5720+10, 160, 6, 20,
-                        NL80211_RRF_PASSIVE_SCAN |
-                        NL80211_RRF_NO_IBSS |
+                        NL80211_RRF_NO_IR |
                         NL80211_RRF_DFS),
 
                 /* IEEE 802.11a, channel 149..165 */
                 REG_RULE(5745-10, 5825+10, 80, 6, 20,
-                        NL80211_RRF_PASSIVE_SCAN |
-                        NL80211_RRF_NO_IBSS),
+                        NL80211_RRF_NO_IR),
 
                 /* IEEE 802.11ad (60gHz), channels 1..3 */
                 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
@@ -208,11 +217,26 @@ static char user_alpha2[2];
 module_param(ieee80211_regdom, charp, 0444);
 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
 
+static void reg_kfree_last_request(void)
+{
+        struct regulatory_request *lr;
+
+        lr = get_last_request();
+
+        if (lr != &core_request_world && lr)
+                kfree_rcu(lr, rcu_head);
+}
+
+static void reg_update_last_request(struct regulatory_request *request)
+{
+        reg_kfree_last_request();
+        rcu_assign_pointer(last_request, request);
+}
+
 static void reset_regdomains(bool full_reset,
                              const struct ieee80211_regdomain *new_regdom)
 {
         const struct ieee80211_regdomain *r;
-        struct regulatory_request *lr;
 
         ASSERT_RTNL();
 
@@ -235,10 +259,7 @@ static void reset_regdomains(bool full_reset,
         if (!full_reset)
                 return;
 
-        lr = get_last_request();
-        if (lr != &core_request_world && lr)
-                kfree_rcu(lr, rcu_head);
-        rcu_assign_pointer(last_request, &core_request_world);
+        reg_update_last_request(&core_request_world);
 }
 
 /*
@@ -456,7 +477,15 @@ static int call_crda(const char *alpha2)
         return kobject_uevent(&reg_pdev->dev.kobj, KOBJ_CHANGE);
 }
 
-static bool reg_is_valid_request(const char *alpha2)
+static enum reg_request_treatment
+reg_call_crda(struct regulatory_request *request)
+{
+        if (call_crda(request->alpha2))
+                return REG_REQ_IGNORE;
+        return REG_REQ_OK;
+}
+
+bool reg_is_valid_request(const char *alpha2)
 {
         struct regulatory_request *lr = get_last_request();
 
@@ -557,6 +586,20 @@ static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
 }
 
 /*
+ * Later on we can perhaps use the more restrictive DFS
+ * region but we don't have information for that yet so
+ * for now simply disallow conflicts.
+ */
+static enum nl80211_dfs_regions
+reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1,
+                         const enum nl80211_dfs_regions dfs_region2)
+{
+        if (dfs_region1 != dfs_region2)
+                return NL80211_DFS_UNSET;
+        return dfs_region1;
+}
+
+/*
  * Helper for regdom_intersect(), this does the real
  * mathematical intersection fun
  */
@@ -687,6 +730,8 @@ regdom_intersect(const struct ieee80211_regdomain *rd1,
         rd->n_reg_rules = num_rules;
         rd->alpha2[0] = '9';
         rd->alpha2[1] = '8';
+        rd->dfs_region = reg_intersect_dfs_region(rd1->dfs_region,
+                                                  rd2->dfs_region);
 
         return rd;
 }
@@ -698,10 +743,8 @@ regdom_intersect(const struct ieee80211_regdomain *rd1,
 static u32 map_regdom_flags(u32 rd_flags)
 {
         u32 channel_flags = 0;
-        if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
-                channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
-        if (rd_flags & NL80211_RRF_NO_IBSS)
-                channel_flags |= IEEE80211_CHAN_NO_IBSS;
+        if (rd_flags & NL80211_RRF_NO_IR_ALL)
+                channel_flags |= IEEE80211_CHAN_NO_IR;
         if (rd_flags & NL80211_RRF_DFS)
                 channel_flags |= IEEE80211_CHAN_RADAR;
         if (rd_flags & NL80211_RRF_NO_OFDM)
@@ -854,8 +897,18 @@ static void handle_channel(struct wiphy *wiphy,
                     PTR_ERR(reg_rule) == -ERANGE)
                         return;
 
-                REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq);
-                chan->flags |= IEEE80211_CHAN_DISABLED;
+                if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
+                    request_wiphy && request_wiphy == wiphy &&
+                    request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
+                        REG_DBG_PRINT("Disabling freq %d MHz for good\n",
+                                      chan->center_freq);
+                        chan->orig_flags |= IEEE80211_CHAN_DISABLED;
+                        chan->flags = chan->orig_flags;
+                } else {
+                        REG_DBG_PRINT("Disabling freq %d MHz\n",
+                                      chan->center_freq);
+                        chan->flags |= IEEE80211_CHAN_DISABLED;
+                }
                 return;
         }
 
@@ -873,7 +926,7 @@ static void handle_channel(struct wiphy *wiphy,
 
         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
             request_wiphy && request_wiphy == wiphy &&
-            request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
+            request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
                 /*
                  * This guarantees the driver's requested regulatory domain
                  * will always be used as a base for further regulatory
@@ -899,13 +952,11 @@ static void handle_channel(struct wiphy *wiphy,
         chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
         if (chan->orig_mpwr) {
                 /*
-                 * Devices that have their own custom regulatory domain
-                 * but also use WIPHY_FLAG_STRICT_REGULATORY will follow the
-                 * passed country IE power settings.
+                 * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
+                 * will always follow the passed country IE power settings.
                  */
                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
-                    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
-                    wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
+                    wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
                         chan->max_power = chan->max_reg_power;
                 else
                         chan->max_power = min(chan->orig_mpwr,
@@ -975,8 +1026,8 @@ static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
 
 static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy)
 {
-        if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY &&
-            !(wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY))
+        if (wiphy->regulatory_flags & REGULATORY_STRICT_REG &&
+            !(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG))
                 return true;
         return false;
 }
@@ -994,7 +1045,7 @@ static bool ignore_reg_update(struct wiphy *wiphy,
         }
 
         if (initiator == NL80211_REGDOM_SET_BY_CORE &&
-            wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
+            wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
                 REG_DBG_PRINT("Ignoring regulatory request set by %s "
                               "since the driver uses its own custom "
                               "regulatory domain\n",
@@ -1032,7 +1083,7 @@ static bool reg_is_world_roaming(struct wiphy *wiphy)
                 return true;
 
         if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
-            wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
+            wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
                 return true;
 
         return false;
@@ -1060,19 +1111,14 @@ static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
         if (!reg_is_world_roaming(wiphy))
                 return;
 
-        if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
+        if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS)
                 return;
 
         chan_before.center_freq = chan->center_freq;
         chan_before.flags = chan->flags;
 
-        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
-                chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
-                channel_changed = true;
-        }
-
-        if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
-                chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
+        if (chan->flags & IEEE80211_CHAN_NO_IR) {
+                chan->flags &= ~IEEE80211_CHAN_NO_IR;
                 channel_changed = true;
         }
 
@@ -1205,14 +1251,30 @@ static void reg_process_ht_flags(struct wiphy *wiphy)
                 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
 }
 
+static void reg_call_notifier(struct wiphy *wiphy,
+                              struct regulatory_request *request)
+{
+        if (wiphy->reg_notifier)
+                wiphy->reg_notifier(wiphy, request);
+}
+
 static void wiphy_update_regulatory(struct wiphy *wiphy,
                                     enum nl80211_reg_initiator initiator)
 {
         enum ieee80211_band band;
         struct regulatory_request *lr = get_last_request();
 
-        if (ignore_reg_update(wiphy, initiator))
+        if (ignore_reg_update(wiphy, initiator)) {
+                /*
+                 * Regulatory updates set by CORE are ignored for custom
+                 * regulatory cards. Let us notify the changes to the driver,
+                 * as some drivers used this to restore its orig_* reg domain.
+                 */
+                if (initiator == NL80211_REGDOM_SET_BY_CORE &&
+                    wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
+                        reg_call_notifier(wiphy, lr);
                 return;
+        }
 
         lr->dfs_region = get_cfg80211_regdom()->dfs_region;
 
@@ -1221,9 +1283,7 @@ static void wiphy_update_regulatory(struct wiphy *wiphy,
 
         reg_process_beacons(wiphy);
         reg_process_ht_flags(wiphy);
-
-        if (wiphy->reg_notifier)
-                wiphy->reg_notifier(wiphy, lr);
+        reg_call_notifier(wiphy, lr);
 }
 
 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
@@ -1236,15 +1296,6 @@ static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
                 wiphy = &rdev->wiphy;
                 wiphy_update_regulatory(wiphy, initiator);
-                /*
-                 * Regulatory updates set by CORE are ignored for custom
-                 * regulatory cards. Let us notify the changes to the driver,
-                 * as some drivers used this to restore its orig_* reg domain.
-                 */
-                if (initiator == NL80211_REGDOM_SET_BY_CORE &&
-                    wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
-                    wiphy->reg_notifier)
-                        wiphy->reg_notifier(wiphy, get_last_request());
         }
 }
 
@@ -1263,7 +1314,8 @@ static void handle_channel_custom(struct wiphy *wiphy,
         if (IS_ERR(reg_rule)) {
                 REG_DBG_PRINT("Disabling freq %d MHz as custom regd has no rule that fits it\n",
                               chan->center_freq);
-                chan->flags = IEEE80211_CHAN_DISABLED;
+                chan->orig_flags |= IEEE80211_CHAN_DISABLED;
+                chan->flags = chan->orig_flags;
                 return;
         }
 
@@ -1305,6 +1357,10 @@ void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
         enum ieee80211_band band;
         unsigned int bands_set = 0;
 
+        WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG),
+             "wiphy should have REGULATORY_CUSTOM_REG\n");
+        wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
+
         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
                 if (!wiphy->bands[band])
                         continue;
@@ -1320,225 +1376,285 @@ void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
 }
 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
 
-/* This has the logic which determines when a new request
- * should be ignored. */
-static enum reg_request_treatment
-get_reg_request_treatment(struct wiphy *wiphy,
-                          struct regulatory_request *pending_request)
+static void reg_set_request_processed(void)
 {
-        struct wiphy *last_wiphy = NULL;
+        bool need_more_processing = false;
         struct regulatory_request *lr = get_last_request();
 
-        /* All initial requests are respected */
-        if (!lr)
-                return REG_REQ_OK;
+        lr->processed = true;
 
-        switch (pending_request->initiator) {
-        case NL80211_REGDOM_SET_BY_CORE:
-                return REG_REQ_OK;
-        case NL80211_REGDOM_SET_BY_COUNTRY_IE:
-                if (reg_request_cell_base(lr)) {
-                        /* Trust a Cell base station over the AP's country IE */
-                        if (regdom_changes(pending_request->alpha2))
-                                return REG_REQ_IGNORE;
-                        return REG_REQ_ALREADY_SET;
-                }
+        spin_lock(&reg_requests_lock);
+        if (!list_empty(&reg_requests_list))
+                need_more_processing = true;
+        spin_unlock(&reg_requests_lock);
 
-                last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
+        if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
+                cancel_delayed_work(&reg_timeout);
 
-                if (unlikely(!is_an_alpha2(pending_request->alpha2)))
-                        return -EINVAL;
-                if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
-                        if (last_wiphy != wiphy) {
-                                /*
-                                 * Two cards with two APs claiming different
-                                 * Country IE alpha2s. We could
-                                 * intersect them, but that seems unlikely
-                                 * to be correct. Reject second one for now.
-                                 */
-                                if (regdom_changes(pending_request->alpha2))
-                                        return REG_REQ_IGNORE;
-                                return REG_REQ_ALREADY_SET;
-                        }
-                        /*
-                         * Two consecutive Country IE hints on the same wiphy.
-                         * This should be picked up early by the driver/stack
-                         */
-                        if (WARN_ON(regdom_changes(pending_request->alpha2)))
-                                return REG_REQ_OK;
-                        return REG_REQ_ALREADY_SET;
-                }
-                return REG_REQ_OK;
-        case NL80211_REGDOM_SET_BY_DRIVER:
-                if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
-                        if (regdom_changes(pending_request->alpha2))
-                                return REG_REQ_OK;
-                        return REG_REQ_ALREADY_SET;
-                }
+        if (need_more_processing)
+                schedule_work(&reg_work);
+}
 
-                /*
-                 * This would happen if you unplug and plug your card
-                 * back in or if you add a new device for which the previously
-                 * loaded card also agrees on the regulatory domain.
-                 */
-                if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
-                    !regdom_changes(pending_request->alpha2))
-                        return REG_REQ_ALREADY_SET;
+/**
+ * reg_process_hint_core - process core regulatory requests
+ * @pending_request: a pending core regulatory request
+ *
+ * The wireless subsystem can use this function to process
+ * a regulatory request issued by the regulatory core.
+ *
+ * Returns one of the different reg request treatment values.
+ */
+static enum reg_request_treatment
+reg_process_hint_core(struct regulatory_request *core_request)
+{
+
+        core_request->intersect = false;
+        core_request->processed = false;
+
+        reg_update_last_request(core_request);
 
+        return reg_call_crda(core_request);
+}
+
+static enum reg_request_treatment
+__reg_process_hint_user(struct regulatory_request *user_request)
+{
+        struct regulatory_request *lr = get_last_request();
+
+        if (reg_request_cell_base(user_request))
+                return reg_ignore_cell_hint(user_request);
+
+        if (reg_request_cell_base(lr))
+                return REG_REQ_IGNORE;
+
+        if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
                 return REG_REQ_INTERSECT;
-        case NL80211_REGDOM_SET_BY_USER:
-                if (reg_request_cell_base(pending_request))
-                        return reg_ignore_cell_hint(pending_request);
+        /*
+         * If the user knows better the user should set the regdom
+         * to their country before the IE is picked up
+         */
+        if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
+            lr->intersect)
+                return REG_REQ_IGNORE;
+        /*
+         * Process user requests only after previous user/driver/core
+         * requests have been processed
+         */
+        if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
+             lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
+             lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
+            regdom_changes(lr->alpha2))
+                return REG_REQ_IGNORE;
 
-                if (reg_request_cell_base(lr))
-                        return REG_REQ_IGNORE;
+        if (!regdom_changes(user_request->alpha2))
+                return REG_REQ_ALREADY_SET;
 
-                if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
-                        return REG_REQ_INTERSECT;
-                /*
-                 * If the user knows better the user should set the regdom
-                 * to their country before the IE is picked up
-                 */
-                if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
-                    lr->intersect)
-                        return REG_REQ_IGNORE;
-                /*
-                 * Process user requests only after previous user/driver/core
-                 * requests have been processed
-                 */
-                if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
-                     lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
-                     lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
-                    regdom_changes(lr->alpha2))
-                        return REG_REQ_IGNORE;
+        return REG_REQ_OK;
+}
 
-                if (!regdom_changes(pending_request->alpha2))
-                        return REG_REQ_ALREADY_SET;
+/**
+ * reg_process_hint_user - process user regulatory requests
+ * @user_request: a pending user regulatory request
+ *
+ * The wireless subsystem can use this function to process
+ * a regulatory request initiated by userspace.
+ *
+ * Returns one of the different reg request treatment values.
+ */
+static enum reg_request_treatment
+reg_process_hint_user(struct regulatory_request *user_request)
+{
+        enum reg_request_treatment treatment;
 
-                return REG_REQ_OK;
+        treatment = __reg_process_hint_user(user_request);
+        if (treatment == REG_REQ_IGNORE ||
+            treatment == REG_REQ_ALREADY_SET) {
+                kfree(user_request);
+                return treatment;
         }
 
-        return REG_REQ_IGNORE;
+        user_request->intersect = treatment == REG_REQ_INTERSECT;
+        user_request->processed = false;
+
+        reg_update_last_request(user_request);
+
+        user_alpha2[0] = user_request->alpha2[0];
+        user_alpha2[1] = user_request->alpha2[1];
+
+        return reg_call_crda(user_request);
 }
 
-static void reg_set_request_processed(void)
+static enum reg_request_treatment
+__reg_process_hint_driver(struct regulatory_request *driver_request)
 {
-        bool need_more_processing = false;
         struct regulatory_request *lr = get_last_request();
 
-        lr->processed = true;
-
-        spin_lock(&reg_requests_lock);
-        if (!list_empty(&reg_requests_list))
-                need_more_processing = true;
-        spin_unlock(&reg_requests_lock);
+        if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
+                if (regdom_changes(driver_request->alpha2))
+                        return REG_REQ_OK;
+                return REG_REQ_ALREADY_SET;
+        }
 
-        if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
-                cancel_delayed_work(&reg_timeout);
+        /*
+         * This would happen if you unplug and plug your card
+         * back in or if you add a new device for which the previously
+         * loaded card also agrees on the regulatory domain.
+         */
+        if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
+            !regdom_changes(driver_request->alpha2))
+                return REG_REQ_ALREADY_SET;
 
-        if (need_more_processing)
-                schedule_work(&reg_work);
+        return REG_REQ_INTERSECT;
 }
 
 /**
- * __regulatory_hint - hint to the wireless core a regulatory domain
- * @wiphy: if the hint comes from country information from an AP, this
- *      is required to be set to the wiphy that received the information
- * @pending_request: the regulatory request currently being processed
+ * reg_process_hint_driver - process driver regulatory requests
+ * @driver_request: a pending driver regulatory request
  *
- * The Wireless subsystem can use this function to hint to the wireless core
- * what it believes should be the current regulatory domain.
+ * The wireless subsystem can use this function to process
+ * a regulatory request issued by an 802.11 driver.
  *
  * Returns one of the different reg request treatment values.
  */
 static enum reg_request_treatment
-__regulatory_hint(struct wiphy *wiphy,
-                  struct regulatory_request *pending_request)
+reg_process_hint_driver(struct wiphy *wiphy,
+                        struct regulatory_request *driver_request)
 {
         const struct ieee80211_regdomain *regd;
-        bool intersect = false;
         enum reg_request_treatment treatment;
-        struct regulatory_request *lr;
 
-        treatment = get_reg_request_treatment(wiphy, pending_request);
+        treatment = __reg_process_hint_driver(driver_request);
 
         switch (treatment) {
-        case REG_REQ_INTERSECT:
-                if (pending_request->initiator ==
-                    NL80211_REGDOM_SET_BY_DRIVER) {
-                        regd = reg_copy_regd(get_cfg80211_regdom());
-                        if (IS_ERR(regd)) {
-                                kfree(pending_request);
-                                return PTR_ERR(regd);
-                        }
-                        rcu_assign_pointer(wiphy->regd, regd);
-                }
-                intersect = true;
-                break;
         case REG_REQ_OK:
                 break;
-        default:
-                /*
-                 * If the regulatory domain being requested by the
-                 * driver has already been set just copy it to the
-                 * wiphy
-                 */
-                if (treatment == REG_REQ_ALREADY_SET &&
-                    pending_request->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
-                        regd = reg_copy_regd(get_cfg80211_regdom());
-                        if (IS_ERR(regd)) {
-                                kfree(pending_request);
-                                return REG_REQ_IGNORE;
-                        }
-                        treatment = REG_REQ_ALREADY_SET;
-                        rcu_assign_pointer(wiphy->regd, regd);
-                        goto new_request;
-                }
-                kfree(pending_request);
+        case REG_REQ_IGNORE:
+                kfree(driver_request);
                 return treatment;
+        case REG_REQ_INTERSECT:
+                /* fall through */
+        case REG_REQ_ALREADY_SET:
+                regd = reg_copy_regd(get_cfg80211_regdom());
+                if (IS_ERR(regd)) {
+                        kfree(driver_request);
+                        return REG_REQ_IGNORE;
+                }
+                rcu_assign_pointer(wiphy->regd, regd);
         }
 
-new_request:
-        lr = get_last_request();
-        if (lr != &core_request_world && lr)
-                kfree_rcu(lr, rcu_head);
 
-        pending_request->intersect = intersect;
-        pending_request->processed = false;
-        rcu_assign_pointer(last_request, pending_request);
-        lr = pending_request;
+        driver_request->intersect = treatment == REG_REQ_INTERSECT;
+        driver_request->processed = false;
 
-        pending_request = NULL;
+        reg_update_last_request(driver_request);
 
-        if (lr->initiator == NL80211_REGDOM_SET_BY_USER) {
-                user_alpha2[0] = lr->alpha2[0];
-                user_alpha2[1] = lr->alpha2[1];
+        /*
+         * Since CRDA will not be called in this case as we already
+         * have applied the requested regulatory domain before we just
+         * inform userspace we have processed the request
+         */
+        if (treatment == REG_REQ_ALREADY_SET) {
+                nl80211_send_reg_change_event(driver_request);
+                reg_set_request_processed();
+                return treatment;
         }
 
-        /* When r == REG_REQ_INTERSECT we do need to call CRDA */
-        if (treatment != REG_REQ_OK && treatment != REG_REQ_INTERSECT) {
+        return reg_call_crda(driver_request);
+}
+
+static enum reg_request_treatment
+__reg_process_hint_country_ie(struct wiphy *wiphy,
+                              struct regulatory_request *country_ie_request)
+{
+        struct wiphy *last_wiphy = NULL;
+        struct regulatory_request *lr = get_last_request();
+
+        if (reg_request_cell_base(lr)) {
+                /* Trust a Cell base station over the AP's country IE */
+                if (regdom_changes(country_ie_request->alpha2))
+                        return REG_REQ_IGNORE;
+                return REG_REQ_ALREADY_SET;
+        } else {
+                if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE)
+                        return REG_REQ_IGNORE;
+        }
+
+        if (unlikely(!is_an_alpha2(country_ie_request->alpha2)))
+                return -EINVAL;
+
+        if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE)
+                return REG_REQ_OK;
+
+        last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
+
+        if (last_wiphy != wiphy) {
                 /*
-                 * Since CRDA will not be called in this case as we already
-                 * have applied the requested regulatory domain before we just
-                 * inform userspace we have processed the request
+                 * Two cards with two APs claiming different
+                 * Country IE alpha2s. We could
+                 * intersect them, but that seems unlikely
+                 * to be correct. Reject second one for now.
                  */
-                if (treatment == REG_REQ_ALREADY_SET) {
-                        nl80211_send_reg_change_event(lr);
-                        reg_set_request_processed();
-                }
-                return treatment;
+                if (regdom_changes(country_ie_request->alpha2))
+                        return REG_REQ_IGNORE;
+                return REG_REQ_ALREADY_SET;
         }
+        /*
+         * Two consecutive Country IE hints on the same wiphy.
+         * This should be picked up early by the driver/stack
+         */
+        if (WARN_ON(regdom_changes(country_ie_request->alpha2)))
+                return REG_REQ_OK;
+        return REG_REQ_ALREADY_SET;
+}
+
+/**
+ * reg_process_hint_country_ie - process regulatory requests from country IEs
+ * @country_ie_request: a regulatory request from a country IE
+ *
+ * The wireless subsystem can use this function to process
+ * a regulatory request issued by a country Information Element.
+ *
+ * Returns one of the different reg request treatment values.
+ */
+static enum reg_request_treatment
+reg_process_hint_country_ie(struct wiphy *wiphy,
+                            struct regulatory_request *country_ie_request)
+{
+        enum reg_request_treatment treatment;
+
+        treatment = __reg_process_hint_country_ie(wiphy, country_ie_request);
 
-        if (call_crda(lr->alpha2))
+        switch (treatment) {
+        case REG_REQ_OK:
+                break;
+        case REG_REQ_IGNORE:
+                /* fall through */
+        case REG_REQ_ALREADY_SET:
+                kfree(country_ie_request);
+                return treatment;
+        case REG_REQ_INTERSECT:
+                kfree(country_ie_request);
+                /*
+                 * This doesn't happen yet, not sure we
+                 * ever want to support it for this case.
+                 */
+                WARN_ONCE(1, "Unexpected intersection for country IEs");
                 return REG_REQ_IGNORE;
-        return REG_REQ_OK;
+        }
+
+        country_ie_request->intersect = false;
+        country_ie_request->processed = false;
+
+        reg_update_last_request(country_ie_request);
+
+        return reg_call_crda(country_ie_request);
 }
 
 /* This processes *all* regulatory hints */
-static void reg_process_hint(struct regulatory_request *reg_request,
-                             enum nl80211_reg_initiator reg_initiator)
+static void reg_process_hint(struct regulatory_request *reg_request)
 {
         struct wiphy *wiphy = NULL;
+        enum reg_request_treatment treatment;
 
         if (WARN_ON(!reg_request->alpha2))
                 return;
@@ -1546,23 +1662,37 @@ static void reg_process_hint(struct regulatory_request *reg_request,
         if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
                 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
 
-        if (reg_initiator == NL80211_REGDOM_SET_BY_DRIVER && !wiphy) {
+        if (reg_request->initiator == NL80211_REGDOM_SET_BY_DRIVER && !wiphy) {
                 kfree(reg_request);
                 return;
         }
 
-        switch (__regulatory_hint(wiphy, reg_request)) {
-        case REG_REQ_ALREADY_SET:
-                /* This is required so that the orig_* parameters are saved */
-                if (wiphy && wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
-                        wiphy_update_regulatory(wiphy, reg_initiator);
+        switch (reg_request->initiator) {
+        case NL80211_REGDOM_SET_BY_CORE:
+                reg_process_hint_core(reg_request);
+                return;
+        case NL80211_REGDOM_SET_BY_USER:
+                treatment = reg_process_hint_user(reg_request);
+                if (treatment == REG_REQ_OK ||
+                    treatment == REG_REQ_ALREADY_SET)
+                        return;
+                schedule_delayed_work(&reg_timeout, msecs_to_jiffies(3142));
+                return;
+        case NL80211_REGDOM_SET_BY_DRIVER:
+                treatment = reg_process_hint_driver(wiphy, reg_request);
                 break;
-        default:
-                if (reg_initiator == NL80211_REGDOM_SET_BY_USER)
-                        schedule_delayed_work(&reg_timeout,
-                                              msecs_to_jiffies(3142));
+        case NL80211_REGDOM_SET_BY_COUNTRY_IE:
+                treatment = reg_process_hint_country_ie(wiphy, reg_request);
                 break;
+        default:
+                WARN(1, "invalid initiator %d\n", reg_request->initiator);
+                return;
         }
+
+        /* This is required so that the orig_* parameters are saved */
+        if (treatment == REG_REQ_ALREADY_SET && wiphy &&
+            wiphy->regulatory_flags & REGULATORY_STRICT_REG)
+                wiphy_update_regulatory(wiphy, reg_request->initiator);
 }
 
 /*
@@ -1596,7 +1726,7 @@ static void reg_process_pending_hints(void)
 
         spin_unlock(&reg_requests_lock);
 
-        reg_process_hint(reg_request, reg_request->initiator);
+        reg_process_hint(reg_request);
 }
 
 /* Processes beacon hints -- this has nothing to do with country IEs */
@@ -1888,7 +2018,7 @@ static void restore_regulatory_settings(bool reset_user)
         world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
 
         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
-                if (rdev->wiphy.flags & WIPHY_FLAG_CUSTOM_REGULATORY)
+                if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG)
                         restore_custom_reg_settings(&rdev->wiphy);
         }
 
@@ -2016,7 +2146,7 @@ static void print_rd_rules(const struct ieee80211_regdomain *rd)
         }
 }
 
-bool reg_supported_dfs_region(u8 dfs_region)
+bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region)
 {
         switch (dfs_region) {
         case NL80211_DFS_UNSET:
@@ -2031,27 +2161,6 @@ bool reg_supported_dfs_region(u8 dfs_region)
         }
 }
 
-static void print_dfs_region(u8 dfs_region)
-{
-        if (!dfs_region)
-                return;
-
-        switch (dfs_region) {
-        case NL80211_DFS_FCC:
-                pr_info(" DFS Master region FCC");
-                break;
-        case NL80211_DFS_ETSI:
-                pr_info(" DFS Master region ETSI");
-                break;
-        case NL80211_DFS_JP:
-                pr_info(" DFS Master region JP");
-                break;
-        default:
-                pr_info(" DFS Master region Unknown");
-                break;
-        }
-}
-
 static void print_regdomain(const struct ieee80211_regdomain *rd)
 {
         struct regulatory_request *lr = get_last_request();
@@ -2083,7 +2192,7 @@ static void print_regdomain(const struct ieee80211_regdomain *rd)
                 }
         }
 
-        print_dfs_region(rd->dfs_region);
+        pr_info(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region));
         print_rd_rules(rd);
 }
 
@@ -2093,48 +2202,60 @@ static void print_regdomain_info(const struct ieee80211_regdomain *rd)
         print_rd_rules(rd);
 }
 
-/* Takes ownership of rd only if it doesn't fail */
-static int __set_regdom(const struct ieee80211_regdomain *rd)
+static int reg_set_rd_core(const struct ieee80211_regdomain *rd)
+{
+        if (!is_world_regdom(rd->alpha2))
+                return -EINVAL;
+        update_world_regdomain(rd);
+        return 0;
+}
+
+static int reg_set_rd_user(const struct ieee80211_regdomain *rd,
+                           struct regulatory_request *user_request)
 {
-        const struct ieee80211_regdomain *regd;
         const struct ieee80211_regdomain *intersected_rd = NULL;
-        struct wiphy *request_wiphy;
-        struct regulatory_request *lr = get_last_request();
 
-        /* Some basic sanity checks first */
+        if (is_world_regdom(rd->alpha2))
+                return -EINVAL;
+
+        if (!regdom_changes(rd->alpha2))
+                return -EALREADY;
 
-        if (!reg_is_valid_request(rd->alpha2))
+        if (!is_valid_rd(rd)) {
+                pr_err("Invalid regulatory domain detected:\n");
+                print_regdomain_info(rd);
                 return -EINVAL;
+        }
 
-        if (is_world_regdom(rd->alpha2)) {
-                update_world_regdomain(rd);
+        if (!user_request->intersect) {
+                reset_regdomains(false, rd);
                 return 0;
         }
 
-        if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
-            !is_unknown_alpha2(rd->alpha2))
+        intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
+        if (!intersected_rd)
                 return -EINVAL;
 
-        /*
-         * Lets only bother proceeding on the same alpha2 if the current
-         * rd is non static (it means CRDA was present and was used last)
-         * and the pending request came in from a country IE
-         */
-        if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
-                /*
-                 * If someone else asked us to change the rd lets only bother
-                 * checking if the alpha2 changes if CRDA was already called
-                 */
-                if (!regdom_changes(rd->alpha2))
-                        return -EALREADY;
-        }
+        kfree(rd);
+        rd = NULL;
+        reset_regdomains(false, intersected_rd);
 
-        /*
-         * Now lets set the regulatory domain, update all driver channels
-         * and finally inform them of what we have done, in case they want
-         * to review or adjust their own settings based on their own
-         * internal EEPROM data
-         */
+        return 0;
+}
+
+static int reg_set_rd_driver(const struct ieee80211_regdomain *rd,
+                             struct regulatory_request *driver_request)
+{
+        const struct ieee80211_regdomain *regd;
+        const struct ieee80211_regdomain *intersected_rd = NULL;
+        const struct ieee80211_regdomain *tmp;
+        struct wiphy *request_wiphy;
+
+        if (is_world_regdom(rd->alpha2))
+                return -EINVAL;
+
+        if (!regdom_changes(rd->alpha2))
+                return -EALREADY;
 
         if (!is_valid_rd(rd)) {
                 pr_err("Invalid regulatory domain detected:\n");
@@ -2142,29 +2263,13 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                 return -EINVAL;
         }
 
-        request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
-        if (!request_wiphy &&
-            (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
-             lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)) {
+        request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx);
+        if (!request_wiphy) {
                 schedule_delayed_work(&reg_timeout, 0);
                 return -ENODEV;
         }
 
-        if (!lr->intersect) {
-                if (lr->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
-                        reset_regdomains(false, rd);
-                        return 0;
-                }
-
-                /*
-                 * For a driver hint, lets copy the regulatory domain the
-                 * driver wanted to the wiphy to deal with conflicts
-                 */
-
-                /*
-                 * Userspace could have sent two replies with only
-                 * one kernel request.
-                 */
+        if (!driver_request->intersect) {
                 if (request_wiphy->regd)
                         return -EALREADY;
 
@@ -2177,38 +2282,59 @@ static int __set_regdom(const struct ieee80211_regdomain *rd)
                 return 0;
         }
 
-        /* Intersection requires a bit more work */
+        intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
+        if (!intersected_rd)
+                return -EINVAL;
 
-        if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
-                intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
-                if (!intersected_rd)
-                        return -EINVAL;
+        /*
+         * We can trash what CRDA provided now.
+         * However if a driver requested this specific regulatory
+         * domain we keep it for its private use
+         */
+        tmp = get_wiphy_regdom(request_wiphy);
+        rcu_assign_pointer(request_wiphy->regd, rd);
+        rcu_free_regdom(tmp);
 
-                /*
-                 * We can trash what CRDA provided now.
-                 * However if a driver requested this specific regulatory
-                 * domain we keep it for its private use
-                 */
-                if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
-                        const struct ieee80211_regdomain *tmp;
+        rd = NULL;
 
-                        tmp = get_wiphy_regdom(request_wiphy);
-                        rcu_assign_pointer(request_wiphy->regd, rd);
-                        rcu_free_regdom(tmp);
-                } else {
-                        kfree(rd);
-                }
+        reset_regdomains(false, intersected_rd);
 
-                rd = NULL;
+        return 0;
+}
 
-                reset_regdomains(false, intersected_rd);
+static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd,
+                                 struct regulatory_request *country_ie_request)
+{
+        struct wiphy *request_wiphy;
 
-                return 0;
+        if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
+            !is_unknown_alpha2(rd->alpha2))
+                return -EINVAL;
+
+        /*
+         * Lets only bother proceeding on the same alpha2 if the current
+         * rd is non static (it means CRDA was present and was used last)
+         * and the pending request came in from a country IE
+         */
+
+        if (!is_valid_rd(rd)) {
+                pr_err("Invalid regulatory domain detected:\n");
+                print_regdomain_info(rd);
+                return -EINVAL;
         }
 
-        return -EINVAL;
-}
+        request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx);
+        if (!request_wiphy) {
+                schedule_delayed_work(&reg_timeout, 0);
+                return -ENODEV;
+        }
+
+        if (country_ie_request->intersect)
+                return -EINVAL;
 
+        reset_regdomains(false, rd);
+        return 0;
+}
 
 /*
  * Use this call to set the current regulatory domain. Conflicts with
@@ -2220,10 +2346,32 @@ int set_regdom(const struct ieee80211_regdomain *rd)
         struct regulatory_request *lr;
         int r;
 
+        if (!reg_is_valid_request(rd->alpha2)) {
+                kfree(rd);
+                return -EINVAL;
+        }
+
         lr = get_last_request();
 
         /* Note that this doesn't update the wiphys, this is done below */
-        r = __set_regdom(rd);
+        switch (lr->initiator) {
+        case NL80211_REGDOM_SET_BY_CORE:
+                r = reg_set_rd_core(rd);
+                break;
+        case NL80211_REGDOM_SET_BY_USER:
+                r = reg_set_rd_user(rd, lr);
+                break;
+        case NL80211_REGDOM_SET_BY_DRIVER:
+                r = reg_set_rd_driver(rd, lr);
+                break;
+        case NL80211_REGDOM_SET_BY_COUNTRY_IE:
+                r = reg_set_rd_country_ie(rd, lr);
+                break;
+        default:
+                WARN(1, "invalid initiator %d\n", lr->initiator);
+                return -EINVAL;
+        }
+
         if (r) {
                 if (r == -EALREADY)
                         reg_set_request_processed();
diff --git a/net/wireless/reg.h b/net/wireless/reg.h
index 9677e3c13da9..cc4c2c0a6723 100644
--- a/net/wireless/reg.h
+++ b/net/wireless/reg.h
@@ -18,8 +18,9 @@
 
 extern const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
 
+bool reg_is_valid_request(const char *alpha2);
 bool is_world_regdom(const char *alpha2);
-bool reg_supported_dfs_region(u8 dfs_region);
+bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region);
 
 int regulatory_hint_user(const char *alpha2,
                          enum nl80211_user_reg_hint_type user_reg_hint_type);
diff --git a/net/wireless/trace.h b/net/wireless/trace.h
index ba5f0d6614d5..f7aa7a72d9bc 100644
--- a/net/wireless/trace.h
+++ b/net/wireless/trace.h
@@ -1653,9 +1653,8 @@ TRACE_EVENT(rdev_cancel_remain_on_channel,
 
 TRACE_EVENT(rdev_mgmt_tx,
         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
-                 struct ieee80211_channel *chan, bool offchan,
-                 unsigned int wait, bool no_cck, bool dont_wait_for_ack),
-        TP_ARGS(wiphy, wdev, chan, offchan, wait, no_cck, dont_wait_for_ack),
+                 struct cfg80211_mgmt_tx_params *params),
+        TP_ARGS(wiphy, wdev, params),
         TP_STRUCT__entry(
                 WIPHY_ENTRY
                 WDEV_ENTRY
@@ -1668,11 +1667,11 @@ TRACE_EVENT(rdev_mgmt_tx,
         TP_fast_assign(
                 WIPHY_ASSIGN;
                 WDEV_ASSIGN;
-                CHAN_ASSIGN(chan);
-                __entry->offchan = offchan;
-                __entry->wait = wait;
-                __entry->no_cck = no_cck;
-                __entry->dont_wait_for_ack = dont_wait_for_ack;
+                CHAN_ASSIGN(params->chan);
+                __entry->offchan = params->offchan;
+                __entry->wait = params->wait;
+                __entry->no_cck = params->no_cck;
+                __entry->dont_wait_for_ack = params->dont_wait_for_ack;
         ),
         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s,"
                   " wait: %u, no cck: %s, dont wait for ack: %s",