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

Conflicts:
	net/bluetooth/l2cap_core.c

20 files changed, 477 insertions, 186 deletions

diff --git a/net/mac80211/aes_ccm.c b/net/mac80211/aes_ccm.c
index b9b595c08112..0785e95c9924 100644
--- a/net/mac80211/aes_ccm.c
+++ b/net/mac80211/aes_ccm.c
@@ -11,6 +11,7 @@
 #include <linux/types.h>
 #include <linux/crypto.h>
 #include <linux/err.h>
+#include <crypto/aes.h>
 
 #include <net/mac80211.h>
 #include "key.h"
@@ -21,21 +22,21 @@ static void aes_ccm_prepare(struct crypto_cipher *tfm, u8 *scratch, u8 *a)
         int i;
         u8 *b_0, *aad, *b, *s_0;
 
-        b_0 = scratch + 3 * AES_BLOCK_LEN;
-        aad = scratch + 4 * AES_BLOCK_LEN;
+        b_0 = scratch + 3 * AES_BLOCK_SIZE;
+        aad = scratch + 4 * AES_BLOCK_SIZE;
         b = scratch;
-        s_0 = scratch + AES_BLOCK_LEN;
+        s_0 = scratch + AES_BLOCK_SIZE;
 
         crypto_cipher_encrypt_one(tfm, b, b_0);
 
         /* Extra Authenticate-only data (always two AES blocks) */
-        for (i = 0; i < AES_BLOCK_LEN; i++)
+        for (i = 0; i < AES_BLOCK_SIZE; i++)
                 aad[i] ^= b[i];
         crypto_cipher_encrypt_one(tfm, b, aad);
 
-        aad += AES_BLOCK_LEN;
+        aad += AES_BLOCK_SIZE;
 
-        for (i = 0; i < AES_BLOCK_LEN; i++)
+        for (i = 0; i < AES_BLOCK_SIZE; i++)
                 aad[i] ^= b[i];
         crypto_cipher_encrypt_one(tfm, a, aad);
 
@@ -57,12 +58,12 @@ void ieee80211_aes_ccm_encrypt(struct crypto_cipher *tfm, u8 *scratch,
         u8 *pos, *cpos, *b, *s_0, *e, *b_0;
 
         b = scratch;
-        s_0 = scratch + AES_BLOCK_LEN;
-        e = scratch + 2 * AES_BLOCK_LEN;
-        b_0 = scratch + 3 * AES_BLOCK_LEN;
+        s_0 = scratch + AES_BLOCK_SIZE;
+        e = scratch + 2 * AES_BLOCK_SIZE;
+        b_0 = scratch + 3 * AES_BLOCK_SIZE;
 
-        num_blocks = DIV_ROUND_UP(data_len, AES_BLOCK_LEN);
-        last_len = data_len % AES_BLOCK_LEN;
+        num_blocks = DIV_ROUND_UP(data_len, AES_BLOCK_SIZE);
+        last_len = data_len % AES_BLOCK_SIZE;
         aes_ccm_prepare(tfm, scratch, b);
 
         /* Process payload blocks */
@@ -70,7 +71,7 @@ void ieee80211_aes_ccm_encrypt(struct crypto_cipher *tfm, u8 *scratch,
         cpos = cdata;
         for (j = 1; j <= num_blocks; j++) {
                 int blen = (j == num_blocks && last_len) ?
-                        last_len : AES_BLOCK_LEN;
+                        last_len : AES_BLOCK_SIZE;
 
                 /* Authentication followed by encryption */
                 for (i = 0; i < blen; i++)
@@ -96,12 +97,12 @@ int ieee80211_aes_ccm_decrypt(struct crypto_cipher *tfm, u8 *scratch,
         u8 *pos, *cpos, *b, *s_0, *a, *b_0;
 
         b = scratch;
-        s_0 = scratch + AES_BLOCK_LEN;
-        a = scratch + 2 * AES_BLOCK_LEN;
-        b_0 = scratch + 3 * AES_BLOCK_LEN;
+        s_0 = scratch + AES_BLOCK_SIZE;
+        a = scratch + 2 * AES_BLOCK_SIZE;
+        b_0 = scratch + 3 * AES_BLOCK_SIZE;
 
-        num_blocks = DIV_ROUND_UP(data_len, AES_BLOCK_LEN);
-        last_len = data_len % AES_BLOCK_LEN;
+        num_blocks = DIV_ROUND_UP(data_len, AES_BLOCK_SIZE);
+        last_len = data_len % AES_BLOCK_SIZE;
         aes_ccm_prepare(tfm, scratch, a);
 
         /* Process payload blocks */
@@ -109,7 +110,7 @@ int ieee80211_aes_ccm_decrypt(struct crypto_cipher *tfm, u8 *scratch,
         pos = data;
         for (j = 1; j <= num_blocks; j++) {
                 int blen = (j == num_blocks && last_len) ?
-                        last_len : AES_BLOCK_LEN;
+                        last_len : AES_BLOCK_SIZE;
 
                 /* Decryption followed by authentication */
                 b_0[14] = (j >> 8) & 0xff;
diff --git a/net/mac80211/aes_ccm.h b/net/mac80211/aes_ccm.h
index 6e7820ef3448..5b7d744e2370 100644
--- a/net/mac80211/aes_ccm.h
+++ b/net/mac80211/aes_ccm.h
@@ -12,8 +12,6 @@
 
 #include <linux/crypto.h>
 
-#define AES_BLOCK_LEN 16
-
 struct crypto_cipher *ieee80211_aes_key_setup_encrypt(const u8 key[]);
 void ieee80211_aes_ccm_encrypt(struct crypto_cipher *tfm, u8 *scratch,
                                u8 *data, size_t data_len,
diff --git a/net/mac80211/aes_cmac.c b/net/mac80211/aes_cmac.c
index d502b2684a66..8dfd70d8fcfb 100644
--- a/net/mac80211/aes_cmac.c
+++ b/net/mac80211/aes_cmac.c
@@ -11,12 +11,12 @@
 #include <linux/types.h>
 #include <linux/crypto.h>
 #include <linux/err.h>
+#include <crypto/aes.h>
 
 #include <net/mac80211.h>
 #include "key.h"
 #include "aes_cmac.h"
 
-#define AES_BLOCK_SIZE 16
 #define AES_CMAC_KEY_LEN 16
 #define CMAC_TLEN 8 /* CMAC TLen = 64 bits (8 octets) */
 #define AAD_LEN 20
@@ -35,10 +35,10 @@ static void gf_mulx(u8 *pad)
 }
 
 
-static void aes_128_cmac_vector(struct crypto_cipher *tfm, u8 *scratch,
-                                size_t num_elem,
+static void aes_128_cmac_vector(struct crypto_cipher *tfm, size_t num_elem,
                                 const u8 *addr[], const size_t *len, u8 *mac)
 {
+        u8 scratch[2 * AES_BLOCK_SIZE];
         u8 *cbc, *pad;
         const u8 *pos, *end;
         size_t i, e, left, total_len;
@@ -95,7 +95,7 @@ static void aes_128_cmac_vector(struct crypto_cipher *tfm, u8 *scratch,
 }
 
 
-void ieee80211_aes_cmac(struct crypto_cipher *tfm, u8 *scratch, const u8 *aad,
+void ieee80211_aes_cmac(struct crypto_cipher *tfm, const u8 *aad,
                         const u8 *data, size_t data_len, u8 *mic)
 {
         const u8 *addr[3];
@@ -110,7 +110,7 @@ void ieee80211_aes_cmac(struct crypto_cipher *tfm, u8 *scratch, const u8 *aad,
         addr[2] = zero;
         len[2] = CMAC_TLEN;
 
-        aes_128_cmac_vector(tfm, scratch, 3, addr, len, mic);
+        aes_128_cmac_vector(tfm, 3, addr, len, mic);
 }
 
 
diff --git a/net/mac80211/aes_cmac.h b/net/mac80211/aes_cmac.h
index 0eb9a4831508..20785a647254 100644
--- a/net/mac80211/aes_cmac.h
+++ b/net/mac80211/aes_cmac.h
@@ -12,7 +12,7 @@
 #include <linux/crypto.h>
 
 struct crypto_cipher * ieee80211_aes_cmac_key_setup(const u8 key[]);
-void ieee80211_aes_cmac(struct crypto_cipher *tfm, u8 *scratch, const u8 *aad,
+void ieee80211_aes_cmac(struct crypto_cipher *tfm, const u8 *aad,
                         const u8 *data, size_t data_len, u8 *mic);
 void ieee80211_aes_cmac_key_free(struct crypto_cipher *tfm);
 
diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index 295ab747663f..bfc36e904764 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -209,6 +209,7 @@ static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
         u8 seq[6] = {0};
         struct key_params params;
         struct ieee80211_key *key = NULL;
+        u64 pn64;
         u32 iv32;
         u16 iv16;
         int err = -ENOENT;
@@ -256,22 +257,24 @@ static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
                 params.seq_len = 6;
                 break;
         case WLAN_CIPHER_SUITE_CCMP:
-                seq[0] = key->u.ccmp.tx_pn[5];
-                seq[1] = key->u.ccmp.tx_pn[4];
-                seq[2] = key->u.ccmp.tx_pn[3];
-                seq[3] = key->u.ccmp.tx_pn[2];
-                seq[4] = key->u.ccmp.tx_pn[1];
-                seq[5] = key->u.ccmp.tx_pn[0];
+                pn64 = atomic64_read(&key->u.ccmp.tx_pn);
+                seq[0] = pn64;
+                seq[1] = pn64 >> 8;
+                seq[2] = pn64 >> 16;
+                seq[3] = pn64 >> 24;
+                seq[4] = pn64 >> 32;
+                seq[5] = pn64 >> 40;
                 params.seq = seq;
                 params.seq_len = 6;
                 break;
         case WLAN_CIPHER_SUITE_AES_CMAC:
-                seq[0] = key->u.aes_cmac.tx_pn[5];
-                seq[1] = key->u.aes_cmac.tx_pn[4];
-                seq[2] = key->u.aes_cmac.tx_pn[3];
-                seq[3] = key->u.aes_cmac.tx_pn[2];
-                seq[4] = key->u.aes_cmac.tx_pn[1];
-                seq[5] = key->u.aes_cmac.tx_pn[0];
+                pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
+                seq[0] = pn64;
+                seq[1] = pn64 >> 8;
+                seq[2] = pn64 >> 16;
+                seq[3] = pn64 >> 24;
+                seq[4] = pn64 >> 32;
+                seq[5] = pn64 >> 40;
                 params.seq = seq;
                 params.seq_len = 6;
                 break;
diff --git a/net/mac80211/debugfs_key.c b/net/mac80211/debugfs_key.c
index 33c58b85c911..38e6101190d9 100644
--- a/net/mac80211/debugfs_key.c
+++ b/net/mac80211/debugfs_key.c
@@ -78,7 +78,7 @@ KEY_OPS(algorithm);
 static ssize_t key_tx_spec_read(struct file *file, char __user *userbuf,
                                 size_t count, loff_t *ppos)
 {
-        const u8 *tpn;
+        u64 pn;
         char buf[20];
         int len;
         struct ieee80211_key *key = file->private_data;
@@ -94,15 +94,16 @@ static ssize_t key_tx_spec_read(struct file *file, char __user *userbuf,
                                 key->u.tkip.tx.iv16);
                 break;
         case WLAN_CIPHER_SUITE_CCMP:
-                tpn = key->u.ccmp.tx_pn;
+                pn = atomic64_read(&key->u.ccmp.tx_pn);
                 len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n",
-                                tpn[0], tpn[1], tpn[2], tpn[3], tpn[4], tpn[5]);
+                                (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24),
+                                (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn);
                 break;
         case WLAN_CIPHER_SUITE_AES_CMAC:
-                tpn = key->u.aes_cmac.tx_pn;
+                pn = atomic64_read(&key->u.aes_cmac.tx_pn);
                 len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n",
-                                tpn[0], tpn[1], tpn[2], tpn[3], tpn[4],
-                                tpn[5]);
+                                (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24),
+                                (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn);
                 break;
         default:
                 return 0;
diff --git a/net/mac80211/driver-ops.h b/net/mac80211/driver-ops.h
index edd2dd79c9be..b2d6bba44054 100644
--- a/net/mac80211/driver-ops.h
+++ b/net/mac80211/driver-ops.h
@@ -657,4 +657,12 @@ static inline void drv_set_rekey_data(struct ieee80211_local *local,
         trace_drv_return_void(local);
 }
 
+static inline void drv_rssi_callback(struct ieee80211_local *local,
+                                     const enum ieee80211_rssi_event event)
+{
+        trace_drv_rssi_callback(local, event);
+        if (local->ops->rssi_callback)
+                local->ops->rssi_callback(&local->hw, event);
+        trace_drv_return_void(local);
+}
 #endif /* __MAC80211_DRIVER_OPS */
diff --git a/net/mac80211/driver-trace.h b/net/mac80211/driver-trace.h
index 31a9dfa81f65..4470f6e8b845 100644
--- a/net/mac80211/driver-trace.h
+++ b/net/mac80211/driver-trace.h
@@ -1052,6 +1052,28 @@ TRACE_EVENT(drv_set_rekey_data,
                   LOCAL_PR_ARG, VIF_PR_ARG)
 );
 
+TRACE_EVENT(drv_rssi_callback,
+        TP_PROTO(struct ieee80211_local *local,
+                 enum ieee80211_rssi_event rssi_event),
+
+        TP_ARGS(local, rssi_event),
+
+        TP_STRUCT__entry(
+                LOCAL_ENTRY
+                __field(u32, rssi_event)
+        ),
+
+        TP_fast_assign(
+                LOCAL_ASSIGN;
+                __entry->rssi_event = rssi_event;
+        ),
+
+        TP_printk(
+                LOCAL_PR_FMT " rssi_event:%d",
+                LOCAL_PR_ARG, __entry->rssi_event
+        )
+);
+
 /*
  * Tracing for API calls that drivers call.
  */
@@ -1342,6 +1364,30 @@ TRACE_EVENT(api_gtk_rekey_notify,
         TP_printk(VIF_PR_FMT, VIF_PR_ARG)
 );
 
+TRACE_EVENT(api_enable_rssi_reports,
+        TP_PROTO(struct ieee80211_sub_if_data *sdata,
+                 int rssi_min_thold, int rssi_max_thold),
+
+        TP_ARGS(sdata, rssi_min_thold, rssi_max_thold),
+
+        TP_STRUCT__entry(
+                VIF_ENTRY
+                __field(int, rssi_min_thold)
+                __field(int, rssi_max_thold)
+        ),
+
+        TP_fast_assign(
+                VIF_ASSIGN;
+                __entry->rssi_min_thold = rssi_min_thold;
+                __entry->rssi_max_thold = rssi_max_thold;
+        ),
+
+        TP_printk(
+                VIF_PR_FMT " rssi_min_thold =%d, rssi_max_thold = %d",
+                VIF_PR_ARG, __entry->rssi_min_thold, __entry->rssi_max_thold
+        )
+);
+
 /*
  * Tracing for internal functions
  * (which may also be called in response to driver calls)
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index 4f2e424e8b1b..dda0d1ab34f3 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -202,7 +202,22 @@ struct ieee80211_rx_data {
         struct ieee80211_key *key;
 
         unsigned int flags;
-        int queue;
+
+        /*
+         * Index into sequence numbers array, 0..16
+         * since the last (16) is used for non-QoS,
+         * will be 16 on non-QoS frames.
+         */
+        int seqno_idx;
+
+        /*
+         * Index into the security IV/PN arrays, 0..16
+         * since the last (16) is used for CCMP-encrypted
+         * management frames, will be set to 16 on mgmt
+         * frames and 0 on non-QoS frames.
+         */
+        int security_idx;
+
         u32 tkip_iv32;
         u16 tkip_iv16;
 };
@@ -417,6 +432,14 @@ struct ieee80211_if_managed {
          * generated for the current association.
          */
         int last_cqm_event_signal;
+
+        /*
+         * State variables for keeping track of RSSI of the AP currently
+         * connected to and informing driver when RSSI has gone
+         * below/above a certain threshold.
+         */
+        int rssi_min_thold, rssi_max_thold;
+        int last_ave_beacon_signal;
 };
 
 struct ieee80211_if_ibss {
@@ -515,12 +538,14 @@ struct ieee80211_if_mesh {
  * @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between
  *      associated stations and deliver multicast frames both
  *      back to wireless media and to the local net stack.
+ * @IEEE80211_SDATA_DISCONNECT_RESUME: Disconnect after resume.
  */
 enum ieee80211_sub_if_data_flags {
         IEEE80211_SDATA_ALLMULTI                = BIT(0),
         IEEE80211_SDATA_PROMISC                 = BIT(1),
         IEEE80211_SDATA_OPERATING_GMODE         = BIT(2),
         IEEE80211_SDATA_DONT_BRIDGE_PACKETS     = BIT(3),
+        IEEE80211_SDATA_DISCONNECT_RESUME       = BIT(4),
 };
 
 /**
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index dee30aea9ab3..cd5fb40d3fd4 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -363,8 +363,7 @@ static int ieee80211_open(struct net_device *dev)
         int err;
 
         /* fail early if user set an invalid address */
-        if (!is_zero_ether_addr(dev->dev_addr) &&
-            !is_valid_ether_addr(dev->dev_addr))
+        if (!is_valid_ether_addr(dev->dev_addr))
                 return -EADDRNOTAVAIL;
 
         err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
@@ -1130,8 +1129,8 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
 
         ASSERT_RTNL();
 
-        ndev = alloc_netdev_mq(sizeof(*sdata) + local->hw.vif_data_size,
-                               name, ieee80211_if_setup, local->hw.queues);
+        ndev = alloc_netdev_mqs(sizeof(*sdata) + local->hw.vif_data_size,
+                                name, ieee80211_if_setup, local->hw.queues, 1);
         if (!ndev)
                 return -ENOMEM;
         dev_net_set(ndev, wiphy_net(local->hw.wiphy));
diff --git a/net/mac80211/key.c b/net/mac80211/key.c
index 1208a7878bfd..739bee13e813 100644
--- a/net/mac80211/key.c
+++ b/net/mac80211/key.c
@@ -369,6 +369,7 @@ struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
                                         get_unaligned_le16(seq);
                         }
                 }
+                spin_lock_init(&key->u.tkip.txlock);
                 break;
         case WLAN_CIPHER_SUITE_CCMP:
                 key->conf.iv_len = CCMP_HDR_LEN;
@@ -625,3 +626,77 @@ void ieee80211_gtk_rekey_notify(struct ieee80211_vif *vif, const u8 *bssid,
         cfg80211_gtk_rekey_notify(sdata->dev, bssid, replay_ctr, gfp);
 }
 EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_notify);
+
+void ieee80211_get_key_tx_seq(struct ieee80211_key_conf *keyconf,
+                              struct ieee80211_key_seq *seq)
+{
+        struct ieee80211_key *key;
+        u64 pn64;
+
+        if (WARN_ON(!(keyconf->flags & IEEE80211_KEY_FLAG_GENERATE_IV)))
+                return;
+
+        key = container_of(keyconf, struct ieee80211_key, conf);
+
+        switch (key->conf.cipher) {
+        case WLAN_CIPHER_SUITE_TKIP:
+                seq->tkip.iv32 = key->u.tkip.tx.iv32;
+                seq->tkip.iv16 = key->u.tkip.tx.iv16;
+                break;
+        case WLAN_CIPHER_SUITE_CCMP:
+                pn64 = atomic64_read(&key->u.ccmp.tx_pn);
+                seq->ccmp.pn[5] = pn64;
+                seq->ccmp.pn[4] = pn64 >> 8;
+                seq->ccmp.pn[3] = pn64 >> 16;
+                seq->ccmp.pn[2] = pn64 >> 24;
+                seq->ccmp.pn[1] = pn64 >> 32;
+                seq->ccmp.pn[0] = pn64 >> 40;
+                break;
+        case WLAN_CIPHER_SUITE_AES_CMAC:
+                pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
+                seq->ccmp.pn[5] = pn64;
+                seq->ccmp.pn[4] = pn64 >> 8;
+                seq->ccmp.pn[3] = pn64 >> 16;
+                seq->ccmp.pn[2] = pn64 >> 24;
+                seq->ccmp.pn[1] = pn64 >> 32;
+                seq->ccmp.pn[0] = pn64 >> 40;
+                break;
+        default:
+                WARN_ON(1);
+        }
+}
+EXPORT_SYMBOL(ieee80211_get_key_tx_seq);
+
+void ieee80211_get_key_rx_seq(struct ieee80211_key_conf *keyconf,
+                              int tid, struct ieee80211_key_seq *seq)
+{
+        struct ieee80211_key *key;
+        const u8 *pn;
+
+        key = container_of(keyconf, struct ieee80211_key, conf);
+
+        switch (key->conf.cipher) {
+        case WLAN_CIPHER_SUITE_TKIP:
+                if (WARN_ON(tid < 0 || tid >= NUM_RX_DATA_QUEUES))
+                        return;
+                seq->tkip.iv32 = key->u.tkip.rx[tid].iv32;
+                seq->tkip.iv16 = key->u.tkip.rx[tid].iv16;
+                break;
+        case WLAN_CIPHER_SUITE_CCMP:
+                if (WARN_ON(tid < -1 || tid >= NUM_RX_DATA_QUEUES))
+                        return;
+                if (tid < 0)
+                        pn = key->u.ccmp.rx_pn[NUM_RX_DATA_QUEUES];
+                else
+                        pn = key->u.ccmp.rx_pn[tid];
+                memcpy(seq->ccmp.pn, pn, CCMP_PN_LEN);
+                break;
+        case WLAN_CIPHER_SUITE_AES_CMAC:
+                if (WARN_ON(tid != 0))
+                        return;
+                pn = key->u.aes_cmac.rx_pn;
+                memcpy(seq->aes_cmac.pn, pn, CMAC_PN_LEN);
+                break;
+        }
+}
+EXPORT_SYMBOL(ieee80211_get_key_rx_seq);
diff --git a/net/mac80211/key.h b/net/mac80211/key.h
index d801d5351336..7d4e31f037d7 100644
--- a/net/mac80211/key.h
+++ b/net/mac80211/key.h
@@ -28,8 +28,9 @@
 #define CCMP_PN_LEN             6
 #define TKIP_IV_LEN             8
 #define TKIP_ICV_LEN            4
+#define CMAC_PN_LEN             6
 
-#define NUM_RX_DATA_QUEUES      17
+#define NUM_RX_DATA_QUEUES      16
 
 struct ieee80211_local;
 struct ieee80211_sub_if_data;
@@ -40,9 +41,11 @@ struct sta_info;
  *
  * @KEY_FLAG_UPLOADED_TO_HARDWARE: Indicates that this key is present
  *      in the hardware for TX crypto hardware acceleration.
+ * @KEY_FLAG_TAINTED: Key is tainted and packets should be dropped.
  */
 enum ieee80211_internal_key_flags {
         KEY_FLAG_UPLOADED_TO_HARDWARE   = BIT(0),
+        KEY_FLAG_TAINTED                = BIT(1),
 };
 
 enum ieee80211_internal_tkip_state {
@@ -52,9 +55,10 @@ enum ieee80211_internal_tkip_state {
 };
 
 struct tkip_ctx {
-        u32 iv32;
-        u16 iv16;
-        u16 p1k[5];
+        u32 iv32;       /* current iv32 */
+        u16 iv16;       /* current iv16 */
+        u16 p1k[5];     /* p1k cache */
+        u32 p1k_iv32;   /* iv32 for which p1k computed */
         enum ieee80211_internal_tkip_state state;
 };
 
@@ -71,6 +75,9 @@ struct ieee80211_key {
 
         union {
                 struct {
+                        /* protects tx context */
+                        spinlock_t txlock;
+
                         /* last used TSC */
                         struct tkip_ctx tx;
 
@@ -78,32 +85,23 @@ struct ieee80211_key {
                         struct tkip_ctx rx[NUM_RX_DATA_QUEUES];
                 } tkip;
                 struct {
-                        u8 tx_pn[6];
+                        atomic64_t tx_pn;
                         /*
                          * Last received packet number. The first
                          * NUM_RX_DATA_QUEUES counters are used with Data
                          * frames and the last counter is used with Robust
                          * Management frames.
                          */
-                        u8 rx_pn[NUM_RX_DATA_QUEUES + 1][6];
+                        u8 rx_pn[NUM_RX_DATA_QUEUES + 1][CCMP_PN_LEN];
                         struct crypto_cipher *tfm;
                         u32 replays; /* dot11RSNAStatsCCMPReplays */
-                        /* scratch buffers for virt_to_page() (crypto API) */
-#ifndef AES_BLOCK_LEN
-#define AES_BLOCK_LEN 16
-#endif
-                        u8 tx_crypto_buf[6 * AES_BLOCK_LEN];
-                        u8 rx_crypto_buf[6 * AES_BLOCK_LEN];
                 } ccmp;
                 struct {
-                        u8 tx_pn[6];
-                        u8 rx_pn[6];
+                        atomic64_t tx_pn;
+                        u8 rx_pn[CMAC_PN_LEN];
                         struct crypto_cipher *tfm;
                         u32 replays; /* dot11RSNAStatsCMACReplays */
                         u32 icverrors; /* dot11RSNAStatsCMACICVErrors */
-                        /* scratch buffers for virt_to_page() (crypto API) */
-                        u8 tx_crypto_buf[2 * AES_BLOCK_LEN];
-                        u8 rx_crypto_buf[2 * AES_BLOCK_LEN];
                 } aes_cmac;
         } u;
 
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 182cda66ebef..c99237cd4b98 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -1763,6 +1763,7 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
                 ifmgd->ave_beacon_signal = rx_status->signal * 16;
                 ifmgd->last_cqm_event_signal = 0;
                 ifmgd->count_beacon_signal = 1;
+                ifmgd->last_ave_beacon_signal = 0;
         } else {
                 ifmgd->ave_beacon_signal =
                         (IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 +
@@ -1770,6 +1771,28 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
                          ifmgd->ave_beacon_signal) / 16;
                 ifmgd->count_beacon_signal++;
         }
+
+        if (ifmgd->rssi_min_thold != ifmgd->rssi_max_thold &&
+            ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT) {
+                int sig = ifmgd->ave_beacon_signal;
+                int last_sig = ifmgd->last_ave_beacon_signal;
+
+                /*
+                 * if signal crosses either of the boundaries, invoke callback
+                 * with appropriate parameters
+                 */
+                if (sig > ifmgd->rssi_max_thold &&
+                    (last_sig <= ifmgd->rssi_min_thold || last_sig == 0)) {
+                        ifmgd->last_ave_beacon_signal = sig;
+                        drv_rssi_callback(local, RSSI_EVENT_HIGH);
+                } else if (sig < ifmgd->rssi_min_thold &&
+                           (last_sig >= ifmgd->rssi_max_thold ||
+                           last_sig == 0)) {
+                        ifmgd->last_ave_beacon_signal = sig;
+                        drv_rssi_callback(local, RSSI_EVENT_LOW);
+                }
+        }
+
         if (bss_conf->cqm_rssi_thold &&
             ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT &&
             !(local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI)) {
@@ -2029,7 +2052,7 @@ static void ieee80211_sta_timer(unsigned long data)
 }
 
 static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
-                                          u8 *bssid)
+                                          u8 *bssid, u8 reason)
 {
         struct ieee80211_local *local = sdata->local;
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
@@ -2047,8 +2070,7 @@ static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
          * but that's not a problem.
          */
         ieee80211_send_deauth_disassoc(sdata, bssid,
-                        IEEE80211_STYPE_DEAUTH,
-                        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
+                        IEEE80211_STYPE_DEAUTH, reason,
                         NULL, true);
         mutex_lock(&ifmgd->mtx);
 }
@@ -2094,7 +2116,8 @@ void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
                                             " AP %pM, disconnecting.\n",
                                             sdata->name, bssid);
 #endif
-                                ieee80211_sta_connection_lost(sdata, bssid);
+                                ieee80211_sta_connection_lost(sdata, bssid,
+                                        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
                         }
                 } else if (time_is_after_jiffies(ifmgd->probe_timeout))
                         run_again(ifmgd, ifmgd->probe_timeout);
@@ -2106,7 +2129,8 @@ void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
                                     sdata->name,
                                     bssid, probe_wait_ms);
 #endif
-                        ieee80211_sta_connection_lost(sdata, bssid);
+                        ieee80211_sta_connection_lost(sdata, bssid,
+                                WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
                 } else if (ifmgd->probe_send_count < max_tries) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
                         wiphy_debug(local->hw.wiphy,
@@ -2128,7 +2152,8 @@ void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
                                     sdata->name,
                                     bssid, probe_wait_ms);
 
-                        ieee80211_sta_connection_lost(sdata, bssid);
+                        ieee80211_sta_connection_lost(sdata, bssid,
+                                WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
                 }
         }
 
@@ -2215,6 +2240,27 @@ void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
+        if (!ifmgd->associated)
+                return;
+
+        if (sdata->flags & IEEE80211_SDATA_DISCONNECT_RESUME) {
+                sdata->flags &= ~IEEE80211_SDATA_DISCONNECT_RESUME;
+                mutex_lock(&ifmgd->mtx);
+                if (ifmgd->associated) {
+#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
+                        wiphy_debug(sdata->local->hw.wiphy,
+                                    "%s: driver requested disconnect after resume.\n",
+                                    sdata->name);
+#endif
+                        ieee80211_sta_connection_lost(sdata,
+                                ifmgd->associated->bssid,
+                                WLAN_REASON_UNSPECIFIED);
+                        mutex_unlock(&ifmgd->mtx);
+                        return;
+                }
+                mutex_unlock(&ifmgd->mtx);
+        }
+
         if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
                 add_timer(&ifmgd->timer);
         if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
index b5493ecd1e93..fe2c2a717793 100644
--- a/net/mac80211/rx.c
+++ b/net/mac80211/rx.c
@@ -331,7 +331,7 @@ static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
 {
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
-        int tid;
+        int tid, seqno_idx, security_idx;
 
         /* does the frame have a qos control field? */
         if (ieee80211_is_data_qos(hdr->frame_control)) {
@@ -340,6 +340,9 @@ static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
                 tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
                 if (*qc & IEEE80211_QOS_CTL_A_MSDU_PRESENT)
                         status->rx_flags |= IEEE80211_RX_AMSDU;
+
+                seqno_idx = tid;
+                security_idx = tid;
         } else {
                 /*
                  * IEEE 802.11-2007, 7.1.3.4.1 ("Sequence Number field"):
@@ -352,10 +355,15 @@ static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
                  *
                  * We also use that counter for non-QoS STAs.
                  */
-                tid = NUM_RX_DATA_QUEUES - 1;
+                seqno_idx = NUM_RX_DATA_QUEUES;
+                security_idx = 0;
+                if (ieee80211_is_mgmt(hdr->frame_control))
+                        security_idx = NUM_RX_DATA_QUEUES;
+                tid = 0;
         }
 
-        rx->queue = tid;
+        rx->seqno_idx = seqno_idx;
+        rx->security_idx = security_idx;
         /* Set skb->priority to 1d tag if highest order bit of TID is not set.
          * For now, set skb->priority to 0 for other cases. */
         rx->skb->priority = (tid > 7) ? 0 : tid;
@@ -810,7 +818,7 @@ ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
         /* Drop duplicate 802.11 retransmissions (IEEE 802.11 Chap. 9.2.9) */
         if (rx->sta && !is_multicast_ether_addr(hdr->addr1)) {
                 if (unlikely(ieee80211_has_retry(hdr->frame_control) &&
-                             rx->sta->last_seq_ctrl[rx->queue] ==
+                             rx->sta->last_seq_ctrl[rx->seqno_idx] ==
                              hdr->seq_ctrl)) {
                         if (status->rx_flags & IEEE80211_RX_RA_MATCH) {
                                 rx->local->dot11FrameDuplicateCount++;
@@ -818,7 +826,7 @@ ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
                         }
                         return RX_DROP_UNUSABLE;
                 } else
-                        rx->sta->last_seq_ctrl[rx->queue] = hdr->seq_ctrl;
+                        rx->sta->last_seq_ctrl[rx->seqno_idx] = hdr->seq_ctrl;
         }
 
         if (unlikely(rx->skb->len < 16)) {
@@ -1011,6 +1019,9 @@ ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
         }
 
         if (rx->key) {
+                if (unlikely(rx->key->flags & KEY_FLAG_TAINTED))
+                        return RX_DROP_MONITOR;
+
                 rx->key->tx_rx_count++;
                 /* TODO: add threshold stuff again */
         } else {
@@ -1374,11 +1385,10 @@ ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
         if (frag == 0) {
                 /* This is the first fragment of a new frame. */
                 entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
-                                                 rx->queue, &(rx->skb));
+                                                 rx->seqno_idx, &(rx->skb));
                 if (rx->key && rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP &&
                     ieee80211_has_protected(fc)) {
-                        int queue = ieee80211_is_mgmt(fc) ?
-                                NUM_RX_DATA_QUEUES : rx->queue;
+                        int queue = rx->security_idx;
                         /* Store CCMP PN so that we can verify that the next
                          * fragment has a sequential PN value. */
                         entry->ccmp = 1;
@@ -1392,7 +1402,8 @@ ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
         /* This is a fragment for a frame that should already be pending in
          * fragment cache. Add this fragment to the end of the pending entry.
          */
-        entry = ieee80211_reassemble_find(rx->sdata, frag, seq, rx->queue, hdr);
+        entry = ieee80211_reassemble_find(rx->sdata, frag, seq,
+                                          rx->seqno_idx, hdr);
         if (!entry) {
                 I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
                 return RX_DROP_MONITOR;
@@ -1412,8 +1423,7 @@ ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
                         if (pn[i])
                                 break;
                 }
-                queue = ieee80211_is_mgmt(fc) ?
-                        NUM_RX_DATA_QUEUES : rx->queue;
+                queue = rx->security_idx;
                 rpn = rx->key->u.ccmp.rx_pn[queue];
                 if (memcmp(pn, rpn, CCMP_PN_LEN))
                         return RX_DROP_UNUSABLE;
@@ -2590,7 +2600,9 @@ void ieee80211_release_reorder_timeout(struct sta_info *sta, int tid)
                 .sta = sta,
                 .sdata = sta->sdata,
                 .local = sta->local,
-                .queue = tid,
+                /* This is OK -- must be QoS data frame */
+                .security_idx = tid,
+                .seqno_idx = tid,
                 .flags = 0,
         };
         struct tid_ampdu_rx *tid_agg_rx;
diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h
index a06d64ebc177..28beb78e601e 100644
--- a/net/mac80211/sta_info.h
+++ b/net/mac80211/sta_info.h
@@ -287,7 +287,8 @@ struct sta_info {
         unsigned long rx_dropped;
         int last_signal;
         struct ewma avg_signal;
-        __le16 last_seq_ctrl[NUM_RX_DATA_QUEUES];
+        /* Plus 1 for non-QoS frames */
+        __le16 last_seq_ctrl[NUM_RX_DATA_QUEUES + 1];
 
         /* Updated from TX status path only, no locking requirements */
         unsigned long tx_filtered_count;
diff --git a/net/mac80211/tkip.c b/net/mac80211/tkip.c
index 757e4eb2baf7..cc79e697cdb2 100644
--- a/net/mac80211/tkip.c
+++ b/net/mac80211/tkip.c
@@ -101,6 +101,7 @@ static void tkip_mixing_phase1(const u8 *tk, struct tkip_ctx *ctx,
                 p1k[4] += tkipS(p1k[3] ^ get_unaligned_le16(tk + 0 + j)) + i;
         }
         ctx->state = TKIP_STATE_PHASE1_DONE;
+        ctx->p1k_iv32 = tsc_IV32;
 }
 
 static void tkip_mixing_phase2(const u8 *tk, struct tkip_ctx *ctx,
@@ -140,60 +141,69 @@ static void tkip_mixing_phase2(const u8 *tk, struct tkip_ctx *ctx,
 /* Add TKIP IV and Ext. IV at @pos. @iv0, @iv1, and @iv2 are the first octets
  * of the IV. Returns pointer to the octet following IVs (i.e., beginning of
  * the packet payload). */
-u8 *ieee80211_tkip_add_iv(u8 *pos, struct ieee80211_key *key, u16 iv16)
+u8 *ieee80211_tkip_add_iv(u8 *pos, struct ieee80211_key *key)
 {
-        pos = write_tkip_iv(pos, iv16);
+        lockdep_assert_held(&key->u.tkip.txlock);
+
+        pos = write_tkip_iv(pos, key->u.tkip.tx.iv16);
         *pos++ = (key->conf.keyidx << 6) | (1 << 5) /* Ext IV */;
         put_unaligned_le32(key->u.tkip.tx.iv32, pos);
         return pos + 4;
 }
 
-void ieee80211_get_tkip_key(struct ieee80211_key_conf *keyconf,
-                        struct sk_buff *skb, enum ieee80211_tkip_key_type type,
-                        u8 *outkey)
+static void ieee80211_compute_tkip_p1k(struct ieee80211_key *key, u32 iv32)
 {
-        struct ieee80211_key *key = (struct ieee80211_key *)
-                        container_of(keyconf, struct ieee80211_key, conf);
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-        u8 *data;
-        const u8 *tk;
-        struct tkip_ctx *ctx;
-        u16 iv16;
-        u32 iv32;
-
-        data = (u8 *)hdr + ieee80211_hdrlen(hdr->frame_control);
-        iv16 = data[2] | (data[0] << 8);
-        iv32 = get_unaligned_le32(&data[4]);
-
-        tk = &key->conf.key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY];
-        ctx = &key->u.tkip.tx;
+        struct ieee80211_sub_if_data *sdata = key->sdata;
+        struct tkip_ctx *ctx = &key->u.tkip.tx;
+        const u8 *tk = &key->conf.key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY];
 
-#ifdef CONFIG_MAC80211_TKIP_DEBUG
-        printk(KERN_DEBUG "TKIP encrypt: iv16 = 0x%04x, iv32 = 0x%08x\n",
-                        iv16, iv32);
-
-        if (iv32 != ctx->iv32) {
-                printk(KERN_DEBUG "skb: iv32 = 0x%08x key: iv32 = 0x%08x\n",
-                        iv32, ctx->iv32);
-                printk(KERN_DEBUG "Wrap around of iv16 in the middle of a "
-                        "fragmented packet\n");
-        }
-#endif
+        lockdep_assert_held(&key->u.tkip.txlock);
+
+        /*
+         * Update the P1K when the IV32 is different from the value it
+         * had when we last computed it (or when not initialised yet).
+         * This might flip-flop back and forth if packets are processed
+         * out-of-order due to the different ACs, but then we have to
+         * just compute the P1K more often.
+         */
+        if (ctx->p1k_iv32 != iv32 || ctx->state == TKIP_STATE_NOT_INIT)
+                tkip_mixing_phase1(tk, ctx, sdata->vif.addr, iv32);
+}
 
-        /* Update the p1k only when the iv16 in the packet wraps around, this
-         * might occur after the wrap around of iv16 in the key in case of
-         * fragmented packets. */
-        if (iv16 == 0 || ctx->state == TKIP_STATE_NOT_INIT)
-                tkip_mixing_phase1(tk, ctx, hdr->addr2, iv32);
+void ieee80211_get_tkip_p1k_iv(struct ieee80211_key_conf *keyconf,
+                               u32 iv32, u16 *p1k)
+{
+        struct ieee80211_key *key = (struct ieee80211_key *)
+                        container_of(keyconf, struct ieee80211_key, conf);
+        struct tkip_ctx *ctx = &key->u.tkip.tx;
+        unsigned long flags;
 
-        if (type == IEEE80211_TKIP_P1_KEY) {
-                memcpy(outkey, ctx->p1k, sizeof(u16) * 5);
-                return;
-        }
+        spin_lock_irqsave(&key->u.tkip.txlock, flags);
+        ieee80211_compute_tkip_p1k(key, iv32);
+        memcpy(p1k, ctx->p1k, sizeof(ctx->p1k));
+        spin_unlock_irqrestore(&key->u.tkip.txlock, flags);
+}
+EXPORT_SYMBOL(ieee80211_get_tkip_p1k_iv);
 
-        tkip_mixing_phase2(tk, ctx, iv16, outkey);
+void ieee80211_get_tkip_p2k(struct ieee80211_key_conf *keyconf,
+                            struct sk_buff *skb, u8 *p2k)
+{
+        struct ieee80211_key *key = (struct ieee80211_key *)
+                        container_of(keyconf, struct ieee80211_key, conf);
+        const u8 *tk = &key->conf.key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY];
+        struct tkip_ctx *ctx = &key->u.tkip.tx;
+        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+        const u8 *data = (u8 *)hdr + ieee80211_hdrlen(hdr->frame_control);
+        u32 iv32 = get_unaligned_le32(&data[4]);
+        u16 iv16 = data[2] | (data[0] << 8);
+        unsigned long flags;
+
+        spin_lock_irqsave(&key->u.tkip.txlock, flags);
+        ieee80211_compute_tkip_p1k(key, iv32);
+        tkip_mixing_phase2(tk, ctx, iv16, p2k);
+        spin_unlock_irqrestore(&key->u.tkip.txlock, flags);
 }
-EXPORT_SYMBOL(ieee80211_get_tkip_key);
+EXPORT_SYMBOL(ieee80211_get_tkip_p2k);
 
 /*
  * Encrypt packet payload with TKIP using @key. @pos is a pointer to the
@@ -204,19 +214,15 @@ EXPORT_SYMBOL(ieee80211_get_tkip_key);
  */
 int ieee80211_tkip_encrypt_data(struct crypto_cipher *tfm,
                                 struct ieee80211_key *key,
-                                u8 *pos, size_t payload_len, u8 *ta)
+                                struct sk_buff *skb,
+                                u8 *payload, size_t payload_len)
 {
         u8 rc4key[16];
-        struct tkip_ctx *ctx = &key->u.tkip.tx;
-        const u8 *tk = &key->conf.key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY];
-
-        /* Calculate per-packet key */
-        if (ctx->iv16 == 0 || ctx->state == TKIP_STATE_NOT_INIT)
-                tkip_mixing_phase1(tk, ctx, ta, ctx->iv32);
 
-        tkip_mixing_phase2(tk, ctx, ctx->iv16, rc4key);
+        ieee80211_get_tkip_p2k(&key->conf, skb, rc4key);
 
-        return ieee80211_wep_encrypt_data(tfm, rc4key, 16, pos, payload_len);
+        return ieee80211_wep_encrypt_data(tfm, rc4key, 16,
+                                          payload, payload_len);
 }
 
 /* Decrypt packet payload with TKIP using @key. @pos is a pointer to the
diff --git a/net/mac80211/tkip.h b/net/mac80211/tkip.h
index 1cab9c86978f..e3ecb659b90a 100644
--- a/net/mac80211/tkip.h
+++ b/net/mac80211/tkip.h
@@ -13,11 +13,13 @@
 #include <linux/crypto.h>
 #include "key.h"
 
-u8 *ieee80211_tkip_add_iv(u8 *pos, struct ieee80211_key *key, u16 iv16);
+u8 *ieee80211_tkip_add_iv(u8 *pos, struct ieee80211_key *key);
 
 int ieee80211_tkip_encrypt_data(struct crypto_cipher *tfm,
-                                 struct ieee80211_key *key,
-                                 u8 *pos, size_t payload_len, u8 *ta);
+                                struct ieee80211_key *key,
+                                struct sk_buff *skb,
+                                u8 *payload, size_t payload_len);
+
 enum {
         TKIP_DECRYPT_OK = 0,
         TKIP_DECRYPT_NO_EXT_IV = -1,
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index e8d0d2d22665..8cb0d2d0ac69 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -589,6 +589,9 @@ ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
                         break;
                 }
 
+                if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED))
+                        return TX_DROP;
+
                 if (!skip_hw && tx->key &&
                     tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
                         info->control.hw_key = &tx->key->conf;
diff --git a/net/mac80211/util.c b/net/mac80211/util.c
index 652e5695225a..5bfb80cba634 100644
--- a/net/mac80211/util.c
+++ b/net/mac80211/util.c
@@ -1334,6 +1334,33 @@ int ieee80211_reconfig(struct ieee80211_local *local)
         return 0;
 }
 
+void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
+{
+        struct ieee80211_sub_if_data *sdata;
+        struct ieee80211_local *local;
+        struct ieee80211_key *key;
+
+        if (WARN_ON(!vif))
+                return;
+
+        sdata = vif_to_sdata(vif);
+        local = sdata->local;
+
+        if (WARN_ON(!local->resuming))
+                return;
+
+        if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
+                return;
+
+        sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
+
+        mutex_lock(&local->key_mtx);
+        list_for_each_entry(key, &sdata->key_list, list)
+                key->flags |= KEY_FLAG_TAINTED;
+        mutex_unlock(&local->key_mtx);
+}
+EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
+
 static int check_mgd_smps(struct ieee80211_if_managed *ifmgd,
                           enum ieee80211_smps_mode *smps_mode)
 {
@@ -1450,3 +1477,43 @@ size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
 
         return pos;
 }
+
+static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
+                                            int rssi_min_thold,
+                                            int rssi_max_thold)
+{
+        trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);
+
+        if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
+                return;
+
+        /*
+         * Scale up threshold values before storing it, as the RSSI averaging
+         * algorithm uses a scaled up value as well. Change this scaling
+         * factor if the RSSI averaging algorithm changes.
+         */
+        sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
+        sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
+}
+
+void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
+                                    int rssi_min_thold,
+                                    int rssi_max_thold)
+{
+        struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
+
+        WARN_ON(rssi_min_thold == rssi_max_thold ||
+                rssi_min_thold > rssi_max_thold);
+
+        _ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
+                                       rssi_max_thold);
+}
+EXPORT_SYMBOL(ieee80211_enable_rssi_reports);
+
+void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
+{
+        struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
+
+        _ieee80211_enable_rssi_reports(sdata, 0, 0);
+}
+EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
diff --git a/net/mac80211/wpa.c b/net/mac80211/wpa.c
index 8f6a302d2ac3..7bc8702808fa 100644
--- a/net/mac80211/wpa.c
+++ b/net/mac80211/wpa.c
@@ -15,6 +15,7 @@
 #include <linux/gfp.h>
 #include <asm/unaligned.h>
 #include <net/mac80211.h>
+#include <crypto/aes.h>
 
 #include "ieee80211_i.h"
 #include "michael.h"
@@ -86,11 +87,6 @@ ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx)
         struct sk_buff *skb = rx->skb;
         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-        int queue = rx->queue;
-
-        /* otherwise, TKIP is vulnerable to TID 0 vs. non-QoS replays */
-        if (rx->queue == NUM_RX_DATA_QUEUES - 1)
-                queue = 0;
 
         /*
          * it makes no sense to check for MIC errors on anything other
@@ -153,8 +149,8 @@ ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx)
 
 update_iv:
         /* update IV in key information to be able to detect replays */
-        rx->key->u.tkip.rx[queue].iv32 = rx->tkip_iv32;
-        rx->key->u.tkip.rx[queue].iv16 = rx->tkip_iv16;
+        rx->key->u.tkip.rx[rx->security_idx].iv32 = rx->tkip_iv32;
+        rx->key->u.tkip.rx[rx->security_idx].iv16 = rx->tkip_iv16;
 
         return RX_CONTINUE;
 
@@ -176,6 +172,7 @@ static int tkip_encrypt_skb(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);
+        unsigned long flags;
         unsigned int hdrlen;
         int len, tail;
         u8 *pos;
@@ -203,11 +200,12 @@ static int tkip_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
         pos += hdrlen;
 
         /* Increase IV for the frame */
+        spin_lock_irqsave(&key->u.tkip.txlock, flags);
         key->u.tkip.tx.iv16++;
         if (key->u.tkip.tx.iv16 == 0)
                 key->u.tkip.tx.iv32++;
-
-        pos = ieee80211_tkip_add_iv(pos, key, key->u.tkip.tx.iv16);
+        pos = ieee80211_tkip_add_iv(pos, key);
+        spin_unlock_irqrestore(&key->u.tkip.txlock, flags);
 
         /* hwaccel - with software IV */
         if (info->control.hw_key)
@@ -216,9 +214,8 @@ static int tkip_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
         /* Add room for ICV */
         skb_put(skb, TKIP_ICV_LEN);
 
-        hdr = (struct ieee80211_hdr *) skb->data;
         return ieee80211_tkip_encrypt_data(tx->local->wep_tx_tfm,
-                                           key, pos, len, hdr->addr2);
+                                           key, skb, pos, len);
 }
 
 
@@ -246,11 +243,6 @@ ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data *rx)
         struct ieee80211_key *key = rx->key;
         struct sk_buff *skb = rx->skb;
         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
-        int queue = rx->queue;
-
-        /* otherwise, TKIP is vulnerable to TID 0 vs. non-QoS replays */
-        if (rx->queue == NUM_RX_DATA_QUEUES - 1)
-                queue = 0;
 
         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 
@@ -271,7 +263,7 @@ ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data *rx)
         res = ieee80211_tkip_decrypt_data(rx->local->wep_rx_tfm,
                                           key, skb->data + hdrlen,
                                           skb->len - hdrlen, rx->sta->sta.addr,
-                                          hdr->addr1, hwaccel, queue,
+                                          hdr->addr1, hwaccel, rx->security_idx,
                                           &rx->tkip_iv32,
                                           &rx->tkip_iv16);
         if (res != TKIP_DECRYPT_OK)
@@ -299,8 +291,10 @@ static void ccmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *scratch,
         unsigned int hdrlen;
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 
-        b_0 = scratch + 3 * AES_BLOCK_LEN;
-        aad = scratch + 4 * AES_BLOCK_LEN;
+        memset(scratch, 0, 6 * AES_BLOCK_SIZE);
+
+        b_0 = scratch + 3 * AES_BLOCK_SIZE;
+        aad = scratch + 4 * AES_BLOCK_SIZE;
 
         /*
          * Mask FC: zero subtype b4 b5 b6 (if not mgmt)
@@ -389,8 +383,10 @@ static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
         struct ieee80211_key *key = tx->key;
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         int hdrlen, len, tail;
-        u8 *pos, *pn;
-        int i;
+        u8 *pos;
+        u8 pn[6];
+        u64 pn64;
+        u8 scratch[6 * AES_BLOCK_SIZE];
 
         if (info->control.hw_key &&
             !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
@@ -418,14 +414,14 @@ static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
         hdr = (struct ieee80211_hdr *) pos;
         pos += hdrlen;
 
-        /* PN = PN + 1 */
-        pn = key->u.ccmp.tx_pn;
+        pn64 = atomic64_inc_return(&key->u.ccmp.tx_pn);
 
-        for (i = CCMP_PN_LEN - 1; i >= 0; i--) {
-                pn[i]++;
-                if (pn[i])
-                        break;
-        }
+        pn[5] = pn64;
+        pn[4] = pn64 >> 8;
+        pn[3] = pn64 >> 16;
+        pn[2] = pn64 >> 24;
+        pn[1] = pn64 >> 32;
+        pn[0] = pn64 >> 40;
 
         ccmp_pn2hdr(pos, pn, key->conf.keyidx);
 
@@ -434,8 +430,8 @@ static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
                 return 0;
 
         pos += CCMP_HDR_LEN;
-        ccmp_special_blocks(skb, pn, key->u.ccmp.tx_crypto_buf, 0);
-        ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, key->u.ccmp.tx_crypto_buf, pos, len,
+        ccmp_special_blocks(skb, pn, scratch, 0);
+        ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, scratch, pos, len,
                                   pos, skb_put(skb, CCMP_MIC_LEN));
 
         return 0;
@@ -482,8 +478,7 @@ ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx)
 
         ccmp_hdr2pn(pn, skb->data + hdrlen);
 
-        queue = ieee80211_is_mgmt(hdr->frame_control) ?
-                NUM_RX_DATA_QUEUES : rx->queue;
+        queue = rx->security_idx;
 
         if (memcmp(pn, key->u.ccmp.rx_pn[queue], CCMP_PN_LEN) <= 0) {
                 key->u.ccmp.replays++;
@@ -491,11 +486,12 @@ ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx)
         }
 
         if (!(status->flag & RX_FLAG_DECRYPTED)) {
+                u8 scratch[6 * AES_BLOCK_SIZE];
                 /* hardware didn't decrypt/verify MIC */
-                ccmp_special_blocks(skb, pn, key->u.ccmp.rx_crypto_buf, 1);
+                ccmp_special_blocks(skb, pn, scratch, 1);
 
                 if (ieee80211_aes_ccm_decrypt(
-                            key->u.ccmp.tfm, key->u.ccmp.rx_crypto_buf,
+                            key->u.ccmp.tfm, scratch,
                             skb->data + hdrlen + CCMP_HDR_LEN, data_len,
                             skb->data + skb->len - CCMP_MIC_LEN,
                             skb->data + hdrlen + CCMP_HDR_LEN))
@@ -526,6 +522,16 @@ static void bip_aad(struct sk_buff *skb, u8 *aad)
 }
 
 
+static inline void bip_ipn_set64(u8 *d, u64 pn)
+{
+        *d++ = pn;
+        *d++ = pn >> 8;
+        *d++ = pn >> 16;
+        *d++ = pn >> 24;
+        *d++ = pn >> 32;
+        *d = pn >> 40;
+}
+
 static inline void bip_ipn_swap(u8 *d, const u8 *s)
 {
         *d++ = s[5];
@@ -544,8 +550,8 @@ ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data *tx)
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct ieee80211_key *key = tx->key;
         struct ieee80211_mmie *mmie;
-        u8 *pn, aad[20];
-        int i;
+        u8 aad[20];
+        u64 pn64;
 
         if (info->control.hw_key)
                 return 0;
@@ -559,22 +565,17 @@ ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data *tx)
         mmie->key_id = cpu_to_le16(key->conf.keyidx);
 
         /* PN = PN + 1 */
-        pn = key->u.aes_cmac.tx_pn;
+        pn64 = atomic64_inc_return(&key->u.aes_cmac.tx_pn);
 
-        for (i = sizeof(key->u.aes_cmac.tx_pn) - 1; i >= 0; i--) {
-                pn[i]++;
-                if (pn[i])
-                        break;
-        }
-        bip_ipn_swap(mmie->sequence_number, pn);
+        bip_ipn_set64(mmie->sequence_number, pn64);
 
         bip_aad(skb, aad);
 
         /*
          * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64)
          */
-        ieee80211_aes_cmac(key->u.aes_cmac.tfm, key->u.aes_cmac.tx_crypto_buf,
-                           aad, skb->data + 24, skb->len - 24, mmie->mic);
+        ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad,
+                           skb->data + 24, skb->len - 24, mmie->mic);
 
         return TX_CONTINUE;
 }
@@ -612,8 +613,7 @@ ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx)
         if (!(status->flag & RX_FLAG_DECRYPTED)) {
                 /* hardware didn't decrypt/verify MIC */
                 bip_aad(skb, aad);
-                ieee80211_aes_cmac(key->u.aes_cmac.tfm,
-                                   key->u.aes_cmac.rx_crypto_buf, aad,
+                ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad,
                                    skb->data + 24, skb->len - 24, mic);
                 if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) {
                         key->u.aes_cmac.icverrors++;