Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / net / mac80211 / mlme.c
index 05a18f4..1e1d16c 100644 (file)
@@ -75,11 +75,8 @@ enum rx_mgmt_action {
        /* caller must call cfg80211_send_disassoc() */
        RX_MGMT_CFG80211_DISASSOC,
 
-       /* caller must call cfg80211_auth_timeout() & free work */
-       RX_MGMT_CFG80211_AUTH_TO,
-
-       /* caller must call cfg80211_assoc_timeout() & free work */
-       RX_MGMT_CFG80211_ASSOC_TO,
+       /* caller must tell cfg80211 about internal error */
+       RX_MGMT_CFG80211_ASSOC_ERROR,
 };
 
 /* utils */
@@ -122,27 +119,6 @@ static int ecw2cw(int ecw)
        return (1 << ecw) - 1;
 }
 
-static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
-                                     struct ieee80211_supported_band *sband,
-                                     u32 *rates)
-{
-       int i, j, count;
-       *rates = 0;
-       count = 0;
-       for (i = 0; i < bss->supp_rates_len; i++) {
-               int rate = (bss->supp_rates[i] & 0x7F) * 5;
-
-               for (j = 0; j < sband->n_bitrates; j++)
-                       if (sband->bitrates[j].bitrate == rate) {
-                               *rates |= BIT(j);
-                               count++;
-                               break;
-                       }
-       }
-
-       return count;
-}
-
 /*
  * ieee80211_enable_ht should be called only after the operating band
  * has been determined as ht configuration depends on the hw's
@@ -202,7 +178,7 @@ static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
                ieee80211_hw_config(local, 0);
 
                rcu_read_lock();
-               sta = sta_info_get(local, bssid);
+               sta = sta_info_get(sdata, bssid);
                if (sta)
                        rate_control_rate_update(local, sband, sta,
                                                 IEEE80211_RC_HT_CHANGED);
@@ -228,209 +204,6 @@ static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
 
 /* frame sending functions */
 
-static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
-                                struct ieee80211_mgd_work *wk)
-{
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-       struct ieee80211_local *local = sdata->local;
-       struct sk_buff *skb;
-       struct ieee80211_mgmt *mgmt;
-       u8 *pos;
-       const u8 *ies, *ht_ie;
-       int i, len, count, rates_len, supp_rates_len;
-       u16 capab;
-       int wmm = 0;
-       struct ieee80211_supported_band *sband;
-       u32 rates = 0;
-
-       skb = dev_alloc_skb(local->hw.extra_tx_headroom +
-                           sizeof(*mgmt) + 200 + wk->ie_len +
-                           wk->ssid_len);
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
-                      "frame\n", sdata->dev->name);
-               return;
-       }
-       skb_reserve(skb, local->hw.extra_tx_headroom);
-
-       sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
-
-       capab = ifmgd->capab;
-
-       if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
-               if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
-                       capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
-               if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
-                       capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
-       }
-
-       if (wk->bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)
-               capab |= WLAN_CAPABILITY_PRIVACY;
-       if (wk->bss->wmm_used)
-               wmm = 1;
-
-       /* get all rates supported by the device and the AP as
-        * some APs don't like getting a superset of their rates
-        * in the association request (e.g. D-Link DAP 1353 in
-        * b-only mode) */
-       rates_len = ieee80211_compatible_rates(wk->bss, sband, &rates);
-
-       if ((wk->bss->cbss.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
-           (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
-               capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
-
-       mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
-       memset(mgmt, 0, 24);
-       memcpy(mgmt->da, wk->bss->cbss.bssid, ETH_ALEN);
-       memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
-       memcpy(mgmt->bssid, wk->bss->cbss.bssid, ETH_ALEN);
-
-       if (!is_zero_ether_addr(wk->prev_bssid)) {
-               skb_put(skb, 10);
-               mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
-                                                 IEEE80211_STYPE_REASSOC_REQ);
-               mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
-               mgmt->u.reassoc_req.listen_interval =
-                               cpu_to_le16(local->hw.conf.listen_interval);
-               memcpy(mgmt->u.reassoc_req.current_ap, wk->prev_bssid,
-                      ETH_ALEN);
-       } else {
-               skb_put(skb, 4);
-               mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
-                                                 IEEE80211_STYPE_ASSOC_REQ);
-               mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
-               mgmt->u.assoc_req.listen_interval =
-                               cpu_to_le16(local->hw.conf.listen_interval);
-       }
-
-       /* SSID */
-       ies = pos = skb_put(skb, 2 + wk->ssid_len);
-       *pos++ = WLAN_EID_SSID;
-       *pos++ = wk->ssid_len;
-       memcpy(pos, wk->ssid, wk->ssid_len);
-
-       /* add all rates which were marked to be used above */
-       supp_rates_len = rates_len;
-       if (supp_rates_len > 8)
-               supp_rates_len = 8;
-
-       len = sband->n_bitrates;
-       pos = skb_put(skb, supp_rates_len + 2);
-       *pos++ = WLAN_EID_SUPP_RATES;
-       *pos++ = supp_rates_len;
-
-       count = 0;
-       for (i = 0; i < sband->n_bitrates; i++) {
-               if (BIT(i) & rates) {
-                       int rate = sband->bitrates[i].bitrate;
-                       *pos++ = (u8) (rate / 5);
-                       if (++count == 8)
-                               break;
-               }
-       }
-
-       if (rates_len > count) {
-               pos = skb_put(skb, rates_len - count + 2);
-               *pos++ = WLAN_EID_EXT_SUPP_RATES;
-               *pos++ = rates_len - count;
-
-               for (i++; i < sband->n_bitrates; i++) {
-                       if (BIT(i) & rates) {
-                               int rate = sband->bitrates[i].bitrate;
-                               *pos++ = (u8) (rate / 5);
-                       }
-               }
-       }
-
-       if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
-               /* 1. power capabilities */
-               pos = skb_put(skb, 4);
-               *pos++ = WLAN_EID_PWR_CAPABILITY;
-               *pos++ = 2;
-               *pos++ = 0; /* min tx power */
-               *pos++ = local->hw.conf.channel->max_power; /* max tx power */
-
-               /* 2. supported channels */
-               /* TODO: get this in reg domain format */
-               pos = skb_put(skb, 2 * sband->n_channels + 2);
-               *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
-               *pos++ = 2 * sband->n_channels;
-               for (i = 0; i < sband->n_channels; i++) {
-                       *pos++ = ieee80211_frequency_to_channel(
-                                       sband->channels[i].center_freq);
-                       *pos++ = 1; /* one channel in the subband*/
-               }
-       }
-
-       if (wk->ie_len && wk->ie) {
-               pos = skb_put(skb, wk->ie_len);
-               memcpy(pos, wk->ie, wk->ie_len);
-       }
-
-       if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {
-               pos = skb_put(skb, 9);
-               *pos++ = WLAN_EID_VENDOR_SPECIFIC;
-               *pos++ = 7; /* len */
-               *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
-               *pos++ = 0x50;
-               *pos++ = 0xf2;
-               *pos++ = 2; /* WME */
-               *pos++ = 0; /* WME info */
-               *pos++ = 1; /* WME ver */
-               *pos++ = 0;
-       }
-
-       /* wmm support is a must to HT */
-       /*
-        * IEEE802.11n does not allow TKIP/WEP as pairwise
-        * ciphers in HT mode. We still associate in non-ht
-        * mode (11a/b/g) if any one of these ciphers is
-        * configured as pairwise.
-        */
-       if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
-           sband->ht_cap.ht_supported &&
-           (ht_ie = ieee80211_bss_get_ie(&wk->bss->cbss, WLAN_EID_HT_INFORMATION)) &&
-           ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&
-           (!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))) {
-               struct ieee80211_ht_info *ht_info =
-                       (struct ieee80211_ht_info *)(ht_ie + 2);
-               u16 cap = sband->ht_cap.cap;
-               __le16 tmp;
-               u32 flags = local->hw.conf.channel->flags;
-
-               switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
-               case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
-                       if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
-                               cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
-                               cap &= ~IEEE80211_HT_CAP_SGI_40;
-                       }
-                       break;
-               case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
-                       if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
-                               cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
-                               cap &= ~IEEE80211_HT_CAP_SGI_40;
-                       }
-                       break;
-               }
-
-               tmp = cpu_to_le16(cap);
-               pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);
-               *pos++ = WLAN_EID_HT_CAPABILITY;
-               *pos++ = sizeof(struct ieee80211_ht_cap);
-               memset(pos, 0, sizeof(struct ieee80211_ht_cap));
-               memcpy(pos, &tmp, sizeof(u16));
-               pos += sizeof(u16);
-               /* TODO: needs a define here for << 2 */
-               *pos++ = sband->ht_cap.ampdu_factor |
-                        (sband->ht_cap.ampdu_density << 2);
-               memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
-       }
-
-       IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
-       ieee80211_tx_skb(sdata, skb);
-}
-
-
 static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
                                           const u8 *bssid, u16 stype, u16 reason,
                                           void *cookie)
@@ -443,7 +216,7 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
        skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
        if (!skb) {
                printk(KERN_DEBUG "%s: failed to allocate buffer for "
-                      "deauth/disassoc frame\n", sdata->dev->name);
+                      "deauth/disassoc frame\n", sdata->name);
                return;
        }
        skb_reserve(skb, local->hw.extra_tx_headroom);
@@ -451,7 +224,7 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
        mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
        memset(mgmt, 0, 24);
        memcpy(mgmt->da, bssid, ETH_ALEN);
-       memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
+       memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
        memcpy(mgmt->bssid, bssid, ETH_ALEN);
        mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
        skb_put(skb, 2);
@@ -476,30 +249,15 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
 void ieee80211_send_pspoll(struct ieee80211_local *local,
                           struct ieee80211_sub_if_data *sdata)
 {
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        struct ieee80211_pspoll *pspoll;
        struct sk_buff *skb;
-       u16 fc;
 
-       skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
-       if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for "
-                      "pspoll frame\n", sdata->dev->name);
+       skb = ieee80211_pspoll_get(&local->hw, &sdata->vif);
+       if (!skb)
                return;
-       }
-       skb_reserve(skb, local->hw.extra_tx_headroom);
 
-       pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
-       memset(pspoll, 0, sizeof(*pspoll));
-       fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;
-       pspoll->frame_control = cpu_to_le16(fc);
-       pspoll->aid = cpu_to_le16(ifmgd->aid);
-
-       /* aid in PS-Poll has its two MSBs each set to 1 */
-       pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
-
-       memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
-       memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);
+       pspoll = (struct ieee80211_pspoll *) skb->data;
+       pspoll->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
 
        IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
        ieee80211_tx_skb(sdata, skb);
@@ -510,30 +268,47 @@ void ieee80211_send_nullfunc(struct ieee80211_local *local,
                             int powersave)
 {
        struct sk_buff *skb;
+       struct ieee80211_hdr_3addr *nullfunc;
+
+       skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif);
+       if (!skb)
+               return;
+
+       nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
+       if (powersave)
+               nullfunc->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
+
+       IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
+       ieee80211_tx_skb(sdata, skb);
+}
+
+static void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
+                                         struct ieee80211_sub_if_data *sdata)
+{
+       struct sk_buff *skb;
        struct ieee80211_hdr *nullfunc;
        __le16 fc;
 
        if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
                return;
 
-       skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
+       skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30);
        if (!skb) {
-               printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
-                      "frame\n", sdata->dev->name);
+               printk(KERN_DEBUG "%s: failed to allocate buffer for 4addr "
+                      "nullfunc frame\n", sdata->name);
                return;
        }
        skb_reserve(skb, local->hw.extra_tx_headroom);
 
-       nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
-       memset(nullfunc, 0, 24);
+       nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30);
+       memset(nullfunc, 0, 30);
        fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
-                        IEEE80211_FCTL_TODS);
-       if (powersave)
-               fc |= cpu_to_le16(IEEE80211_FCTL_PM);
+                        IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
        nullfunc->frame_control = fc;
        memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
-       memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
+       memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
        memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
+       memcpy(nullfunc->addr4, sdata->vif.addr, ETH_ALEN);
 
        IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
        ieee80211_tx_skb(sdata, skb);
@@ -546,7 +321,7 @@ static void ieee80211_chswitch_work(struct work_struct *work)
                container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
-       if (!netif_running(sdata->dev))
+       if (!ieee80211_sdata_running(sdata))
                return;
 
        mutex_lock(&ifmgd->mtx);
@@ -557,7 +332,7 @@ static void ieee80211_chswitch_work(struct work_struct *work)
        ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL);
 
        /* XXX: shouldn't really modify cfg80211-owned data! */
-       ifmgd->associated->cbss.channel = sdata->local->oper_channel;
+       ifmgd->associated->channel = sdata->local->oper_channel;
 
        ieee80211_wake_queues_by_reason(&sdata->local->hw,
                                        IEEE80211_QUEUE_STOP_REASON_CSA);
@@ -584,6 +359,8 @@ void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
                                      struct ieee80211_channel_sw_ie *sw_elem,
                                      struct ieee80211_bss *bss)
 {
+       struct cfg80211_bss *cbss =
+               container_of((void *)bss, struct cfg80211_bss, priv);
        struct ieee80211_channel *new_ch;
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);
@@ -617,7 +394,7 @@ void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
                mod_timer(&ifmgd->chswitch_timer,
                          jiffies +
                          msecs_to_jiffies(sw_elem->count *
-                                          bss->cbss.beacon_interval));
+                                          cbss->beacon_interval));
        }
 }
 
@@ -691,8 +468,13 @@ void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
                return;
        }
 
+       if (!list_empty(&local->work_list)) {
+               local->ps_sdata = NULL;
+               goto change;
+       }
+
        list_for_each_entry(sdata, &local->interfaces, list) {
-               if (!netif_running(sdata->dev))
+               if (!ieee80211_sdata_running(sdata))
                        continue;
                if (sdata->vif.type != NL80211_IFTYPE_STATION)
                        continue;
@@ -701,7 +483,7 @@ void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
        }
 
        if (count == 1 && found->u.mgd.powersave &&
-           found->u.mgd.associated && list_empty(&found->u.mgd.work_list) &&
+           found->u.mgd.associated &&
            !(found->u.mgd.flags & (IEEE80211_STA_BEACON_POLL |
                                    IEEE80211_STA_CONNECTION_POLL))) {
                s32 beaconint_us;
@@ -729,6 +511,7 @@ void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
                local->ps_sdata = NULL;
        }
 
+ change:
        ieee80211_change_ps(local);
 }
 
@@ -786,9 +569,9 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
        struct ieee80211_tx_queue_params params;
        size_t left;
        int count;
-       u8 *pos;
+       u8 *pos, uapsd_queues = 0;
 
-       if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))
+       if (local->hw.queues < 4)
                return;
 
        if (!wmm_param)
@@ -796,6 +579,10 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
 
        if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
                return;
+
+       if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
+               uapsd_queues = local->uapsd_queues;
+
        count = wmm_param[6] & 0x0f;
        if (count == ifmgd->wmm_last_param_set)
                return;
@@ -810,6 +597,7 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
        for (; left >= 4; left -= 4, pos += 4) {
                int aci = (pos[0] >> 5) & 0x03;
                int acm = (pos[0] >> 4) & 0x01;
+               bool uapsd = false;
                int queue;
 
                switch (aci) {
@@ -817,22 +605,30 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
                        queue = 3;
                        if (acm)
                                local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
+                       if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
+                               uapsd = true;
                        break;
                case 2: /* AC_VI */
                        queue = 1;
                        if (acm)
                                local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
+                       if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
+                               uapsd = true;
                        break;
                case 3: /* AC_VO */
                        queue = 0;
                        if (acm)
                                local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
+                       if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
+                               uapsd = true;
                        break;
                case 0: /* AC_BE */
                default:
                        queue = 2;
                        if (acm)
                                local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
+                       if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
+                               uapsd = true;
                        break;
                }
 
@@ -840,11 +636,14 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
                params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
                params.cw_min = ecw2cw(pos[1] & 0x0f);
                params.txop = get_unaligned_le16(pos + 2);
+               params.uapsd = uapsd;
+
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
                printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
-                      "cWmin=%d cWmax=%d txop=%d\n",
+                      "cWmin=%d cWmax=%d txop=%d uapsd=%d\n",
                       wiphy_name(local->hw.wiphy), queue, aci, acm,
-                      params.aifs, params.cw_min, params.cw_max, params.txop);
+                      params.aifs, params.cw_min, params.cw_max, params.txop,
+                      params.uapsd);
 #endif
                if (drv_conf_tx(local, queue, &params) && local->ops->conf_tx)
                        printk(KERN_DEBUG "%s: failed to set TX queue "
@@ -871,6 +670,8 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
        }
 
        use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
+       if (sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ)
+               use_short_slot = true;
 
        if (use_protection != bss_conf->use_cts_prot) {
                bss_conf->use_cts_prot = use_protection;
@@ -891,25 +692,24 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
 }
 
 static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
-                                    struct ieee80211_mgd_work *wk,
+                                    struct cfg80211_bss *cbss,
                                     u32 bss_info_changed)
 {
+       struct ieee80211_bss *bss = (void *)cbss->priv;
        struct ieee80211_local *local = sdata->local;
-       struct ieee80211_bss *bss = wk->bss;
 
        bss_info_changed |= BSS_CHANGED_ASSOC;
        /* set timing information */
-       sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;
-       sdata->vif.bss_conf.timestamp = bss->cbss.tsf;
+       sdata->vif.bss_conf.beacon_int = cbss->beacon_interval;
+       sdata->vif.bss_conf.timestamp = cbss->tsf;
        sdata->vif.bss_conf.dtim_period = bss->dtim_period;
 
        bss_info_changed |= BSS_CHANGED_BEACON_INT;
        bss_info_changed |= ieee80211_handle_bss_capability(sdata,
-               bss->cbss.capability, bss->has_erp_value, bss->erp_value);
+               cbss->capability, bss->has_erp_value, bss->erp_value);
 
-       sdata->u.mgd.associated = bss;
-       sdata->u.mgd.old_associate_work = wk;
-       memcpy(sdata->u.mgd.bssid, bss->cbss.bssid, ETH_ALEN);
+       sdata->u.mgd.associated = cbss;
+       memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN);
 
        /* just to be sure */
        sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
@@ -940,99 +740,14 @@ static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
 
        mutex_lock(&local->iflist_mtx);
        ieee80211_recalc_ps(local, -1);
+       ieee80211_recalc_smps(local, sdata);
        mutex_unlock(&local->iflist_mtx);
 
        netif_tx_start_all_queues(sdata->dev);
        netif_carrier_on(sdata->dev);
 }
 
-static enum rx_mgmt_action __must_check
-ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata,
-                      struct ieee80211_mgd_work *wk)
-{
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-       struct ieee80211_local *local = sdata->local;
-
-       wk->tries++;
-       if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
-               printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
-                      sdata->dev->name, wk->bss->cbss.bssid);
-
-               /*
-                * Most likely AP is not in the range so remove the
-                * bss struct for that AP.
-                */
-               cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
-
-               /*
-                * We might have a pending scan which had no chance to run yet
-                * due to work needing to be done. Hence, queue the STAs work
-                * again for that.
-                */
-               ieee80211_queue_work(&local->hw, &ifmgd->work);
-               return RX_MGMT_CFG80211_AUTH_TO;
-       }
-
-       printk(KERN_DEBUG "%s: direct probe to AP %pM (try %d)\n",
-                       sdata->dev->name, wk->bss->cbss.bssid,
-                       wk->tries);
-
-       /*
-        * Direct probe is sent to broadcast address as some APs
-        * will not answer to direct packet in unassociated state.
-        */
-       ieee80211_send_probe_req(sdata, NULL, wk->ssid, wk->ssid_len, NULL, 0);
-
-       wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
-       run_again(ifmgd, wk->timeout);
-
-       return RX_MGMT_NONE;
-}
-
-
-static enum rx_mgmt_action __must_check
-ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,
-                      struct ieee80211_mgd_work *wk)
-{
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-       struct ieee80211_local *local = sdata->local;
-
-       wk->tries++;
-       if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
-               printk(KERN_DEBUG "%s: authentication with AP %pM"
-                      " timed out\n",
-                      sdata->dev->name, wk->bss->cbss.bssid);
-
-               /*
-                * Most likely AP is not in the range so remove the
-                * bss struct for that AP.
-                */
-               cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
-
-               /*
-                * We might have a pending scan which had no chance to run yet
-                * due to work needing to be done. Hence, queue the STAs work
-                * again for that.
-                */
-               ieee80211_queue_work(&local->hw, &ifmgd->work);
-               return RX_MGMT_CFG80211_AUTH_TO;
-       }
-
-       printk(KERN_DEBUG "%s: authenticate with AP %pM (try %d)\n",
-              sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
-
-       ieee80211_send_auth(sdata, 1, wk->auth_alg, wk->ie, wk->ie_len,
-                           wk->bss->cbss.bssid, NULL, 0, 0);
-       wk->auth_transaction = 2;
-
-       wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
-       run_again(ifmgd, wk->timeout);
-
-       return RX_MGMT_NONE;
-}
-
-static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
-                                  bool deauth)
+static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata)
 {
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        struct ieee80211_local *local = sdata->local;
@@ -1045,21 +760,11 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
        if (WARN_ON(!ifmgd->associated))
                return;
 
-       memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
+       memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
 
        ifmgd->associated = NULL;
        memset(ifmgd->bssid, 0, ETH_ALEN);
 
-       if (deauth) {
-               kfree(ifmgd->old_associate_work);
-               ifmgd->old_associate_work = NULL;
-       } else {
-               struct ieee80211_mgd_work *wk = ifmgd->old_associate_work;
-
-               wk->state = IEEE80211_MGD_STATE_IDLE;
-               list_add(&wk->list, &ifmgd->work_list);
-       }
-
        /*
         * we need to commit the associated = NULL change because the
         * scan code uses that to determine whether this iface should
@@ -1078,7 +783,7 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
        netif_carrier_off(sdata->dev);
 
        rcu_read_lock();
-       sta = sta_info_get(local, bssid);
+       sta = sta_info_get(sdata, bssid);
        if (sta)
                ieee80211_sta_tear_down_BA_sessions(sta);
        rcu_read_unlock();
@@ -1115,7 +820,7 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
 
        rcu_read_lock();
 
-       sta = sta_info_get(local, bssid);
+       sta = sta_info_get(sdata, bssid);
        if (!sta) {
                rcu_read_unlock();
                return;
@@ -1128,44 +833,6 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
        sta_info_destroy(sta);
 }
 
-static enum rx_mgmt_action __must_check
-ieee80211_associate(struct ieee80211_sub_if_data *sdata,
-                   struct ieee80211_mgd_work *wk)
-{
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-       struct ieee80211_local *local = sdata->local;
-
-       wk->tries++;
-       if (wk->tries > IEEE80211_ASSOC_MAX_TRIES) {
-               printk(KERN_DEBUG "%s: association with AP %pM"
-                      " timed out\n",
-                      sdata->dev->name, wk->bss->cbss.bssid);
-
-               /*
-                * Most likely AP is not in the range so remove the
-                * bss struct for that AP.
-                */
-               cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
-
-               /*
-                * We might have a pending scan which had no chance to run yet
-                * due to work needing to be done. Hence, queue the STAs work
-                * again for that.
-                */
-               ieee80211_queue_work(&local->hw, &ifmgd->work);
-               return RX_MGMT_CFG80211_ASSOC_TO;
-       }
-
-       printk(KERN_DEBUG "%s: associate with AP %pM (try %d)\n",
-              sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
-       ieee80211_send_assoc(sdata, wk);
-
-       wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
-       run_again(ifmgd, wk->timeout);
-
-       return RX_MGMT_NONE;
-}
-
 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
                             struct ieee80211_hdr *hdr)
 {
@@ -1189,8 +856,8 @@ static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        const u8 *ssid;
 
-       ssid = ieee80211_bss_get_ie(&ifmgd->associated->cbss, WLAN_EID_SSID);
-       ieee80211_send_probe_req(sdata, ifmgd->associated->cbss.bssid,
+       ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
+       ieee80211_send_probe_req(sdata, ifmgd->associated->bssid,
                                 ssid + 2, ssid[1], NULL, 0);
 
        ifmgd->probe_send_count++;
@@ -1204,12 +871,15 @@ static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        bool already = false;
 
-       if (!netif_running(sdata->dev))
+       if (!ieee80211_sdata_running(sdata))
                return;
 
        if (sdata->local->scanning)
                return;
 
+       if (sdata->local->tmp_channel)
+               return;
+
        mutex_lock(&ifmgd->mtx);
 
        if (!ifmgd->associated)
@@ -1218,7 +888,7 @@ static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
        if (beacon && net_ratelimit())
                printk(KERN_DEBUG "%s: detected beacon loss from AP "
-                      "- sending probe request\n", sdata->dev->name);
+                      "- sending probe request\n", sdata->name);
 #endif
 
        /*
@@ -1271,88 +941,8 @@ void ieee80211_beacon_loss(struct ieee80211_vif *vif)
 }
 EXPORT_SYMBOL(ieee80211_beacon_loss);
 
-static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata,
-                                    struct ieee80211_mgd_work *wk)
-{
-       wk->state = IEEE80211_MGD_STATE_IDLE;
-       printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
-}
-
-
-static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
-                                    struct ieee80211_mgd_work *wk,
-                                    struct ieee80211_mgmt *mgmt,
-                                    size_t len)
-{
-       u8 *pos;
-       struct ieee802_11_elems elems;
-
-       pos = mgmt->u.auth.variable;
-       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
-       if (!elems.challenge)
-               return;
-       ieee80211_send_auth(sdata, 3, wk->auth_alg,
-                           elems.challenge - 2, elems.challenge_len + 2,
-                           wk->bss->cbss.bssid,
-                           wk->key, wk->key_len, wk->key_idx);
-       wk->auth_transaction = 4;
-}
-
-static enum rx_mgmt_action __must_check
-ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
-                      struct ieee80211_mgd_work *wk,
-                      struct ieee80211_mgmt *mgmt, size_t len)
-{
-       u16 auth_alg, auth_transaction, status_code;
-
-       if (wk->state != IEEE80211_MGD_STATE_AUTH)
-               return RX_MGMT_NONE;
-
-       if (len < 24 + 6)
-               return RX_MGMT_NONE;
-
-       if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
-               return RX_MGMT_NONE;
-
-       if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
-               return RX_MGMT_NONE;
-
-       auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
-       auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
-       status_code = le16_to_cpu(mgmt->u.auth.status_code);
-
-       if (auth_alg != wk->auth_alg ||
-           auth_transaction != wk->auth_transaction)
-               return RX_MGMT_NONE;
-
-       if (status_code != WLAN_STATUS_SUCCESS) {
-               list_del(&wk->list);
-               kfree(wk);
-               return RX_MGMT_CFG80211_AUTH;
-       }
-
-       switch (wk->auth_alg) {
-       case WLAN_AUTH_OPEN:
-       case WLAN_AUTH_LEAP:
-       case WLAN_AUTH_FT:
-               ieee80211_auth_completed(sdata, wk);
-               return RX_MGMT_CFG80211_AUTH;
-       case WLAN_AUTH_SHARED_KEY:
-               if (wk->auth_transaction == 4) {
-                       ieee80211_auth_completed(sdata, wk);
-                       return RX_MGMT_CFG80211_AUTH;
-               } else
-                       ieee80211_auth_challenge(sdata, wk, mgmt, len);
-               break;
-       }
-
-       return RX_MGMT_NONE;
-}
-
-
 static enum rx_mgmt_action __must_check
 ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
-                        struct ieee80211_mgd_work *wk,
                         struct ieee80211_mgmt *mgmt, size_t len)
 {
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
@@ -1364,23 +954,15 @@ ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
 
        ASSERT_MGD_MTX(ifmgd);
 
-       if (wk)
-               bssid = wk->bss->cbss.bssid;
-       else
-               bssid = ifmgd->associated->cbss.bssid;
+       bssid = ifmgd->associated->bssid;
 
        reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
 
        printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
-                       sdata->dev->name, bssid, reason_code);
+                       sdata->name, bssid, reason_code);
 
-       if (!wk) {
-               ieee80211_set_disassoc(sdata, true);
-               ieee80211_recalc_idle(sdata->local);
-       } else {
-               list_del(&wk->list);
-               kfree(wk);
-       }
+       ieee80211_set_disassoc(sdata);
+       ieee80211_recalc_idle(sdata->local);
 
        return RX_MGMT_CFG80211_DEAUTH;
 }
@@ -1401,123 +983,72 @@ ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
        if (WARN_ON(!ifmgd->associated))
                return RX_MGMT_NONE;
 
-       if (WARN_ON(memcmp(ifmgd->associated->cbss.bssid, mgmt->sa, ETH_ALEN)))
+       if (WARN_ON(memcmp(ifmgd->associated->bssid, mgmt->sa, ETH_ALEN)))
                return RX_MGMT_NONE;
 
        reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
 
        printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
-                       sdata->dev->name, mgmt->sa, reason_code);
+                       sdata->name, mgmt->sa, reason_code);
 
-       ieee80211_set_disassoc(sdata, false);
+       ieee80211_set_disassoc(sdata);
        ieee80211_recalc_idle(sdata->local);
        return RX_MGMT_CFG80211_DISASSOC;
 }
 
 
-static enum rx_mgmt_action __must_check
-ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
-                            struct ieee80211_mgd_work *wk,
-                            struct ieee80211_mgmt *mgmt, size_t len,
-                            bool reassoc)
+static bool ieee80211_assoc_success(struct ieee80211_work *wk,
+                                   struct ieee80211_mgmt *mgmt, size_t len)
 {
+       struct ieee80211_sub_if_data *sdata = wk->sdata;
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        struct ieee80211_local *local = sdata->local;
        struct ieee80211_supported_band *sband;
        struct sta_info *sta;
+       struct cfg80211_bss *cbss = wk->assoc.bss;
+       u8 *pos;
        u32 rates, basic_rates;
-       u16 capab_info, status_code, aid;
+       u16 capab_info, aid;
        struct ieee802_11_elems elems;
        struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
-       u8 *pos;
        u32 changed = 0;
-       int i, j;
-       bool have_higher_than_11mbit = false, newsta = false;
+       int i, j, err;
+       bool have_higher_than_11mbit = false;
        u16 ap_ht_cap_flags;
 
-       /*
-        * AssocResp and ReassocResp have identical structure, so process both
-        * of them in this function.
-        */
-
-       if (len < 24 + 6)
-               return RX_MGMT_NONE;
-
-       if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
-               return RX_MGMT_NONE;
+       /* AssocResp and ReassocResp have identical structure */
 
-       capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
-       status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
        aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
-
-       printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
-              "status=%d aid=%d)\n",
-              sdata->dev->name, reassoc ? "Rea" : "A", mgmt->sa,
-              capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
-
-       pos = mgmt->u.assoc_resp.variable;
-       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
-
-       if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
-           elems.timeout_int && elems.timeout_int_len == 5 &&
-           elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
-               u32 tu, ms;
-               tu = get_unaligned_le32(elems.timeout_int + 1);
-               ms = tu * 1024 / 1000;
-               printk(KERN_DEBUG "%s: AP rejected association temporarily; "
-                      "comeback duration %u TU (%u ms)\n",
-                      sdata->dev->name, tu, ms);
-               wk->timeout = jiffies + msecs_to_jiffies(ms);
-               if (ms > IEEE80211_ASSOC_TIMEOUT)
-                       run_again(ifmgd, jiffies + msecs_to_jiffies(ms));
-               return RX_MGMT_NONE;
-       }
-
-       if (status_code != WLAN_STATUS_SUCCESS) {
-               printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",
-                      sdata->dev->name, status_code);
-               wk->state = IEEE80211_MGD_STATE_IDLE;
-               return RX_MGMT_CFG80211_ASSOC;
-       }
+       capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
 
        if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
                printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
-                      "set\n", sdata->dev->name, aid);
+                      "set\n", sdata->name, aid);
        aid &= ~(BIT(15) | BIT(14));
 
+       pos = mgmt->u.assoc_resp.variable;
+       ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
+
        if (!elems.supp_rates) {
                printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
-                      sdata->dev->name);
-               return RX_MGMT_NONE;
+                      sdata->name);
+               return false;
        }
 
-       printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);
        ifmgd->aid = aid;
 
-       rcu_read_lock();
-
-       /* Add STA entry for the AP */
-       sta = sta_info_get(local, wk->bss->cbss.bssid);
+       sta = sta_info_alloc(sdata, cbss->bssid, GFP_KERNEL);
        if (!sta) {
-               newsta = true;
-
-               rcu_read_unlock();
-
-               sta = sta_info_alloc(sdata, wk->bss->cbss.bssid, GFP_KERNEL);
-               if (!sta) {
-                       printk(KERN_DEBUG "%s: failed to alloc STA entry for"
-                              " the AP\n", sdata->dev->name);
-                       return RX_MGMT_NONE;
-               }
-
-               set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC |
-                                  WLAN_STA_ASSOC_AP);
-               if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
-                       set_sta_flags(sta, WLAN_STA_AUTHORIZED);
-
-               rcu_read_lock();
+               printk(KERN_DEBUG "%s: failed to alloc STA entry for"
+                      " the AP\n", sdata->name);
+               return false;
        }
 
+       set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC |
+                          WLAN_STA_ASSOC_AP);
+       if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
+               set_sta_flags(sta, WLAN_STA_AUTHORIZED);
+
        rates = 0;
        basic_rates = 0;
        sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
@@ -1580,40 +1111,40 @@ ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
        if (elems.wmm_param)
                set_sta_flags(sta, WLAN_STA_WME);
 
-       if (newsta) {
-               int err = sta_info_insert(sta);
-               if (err) {
-                       printk(KERN_DEBUG "%s: failed to insert STA entry for"
-                              " the AP (error %d)\n", sdata->dev->name, err);
-                       rcu_read_unlock();
-                       return RX_MGMT_NONE;
-               }
+       err = sta_info_insert(sta);
+       sta = NULL;
+       if (err) {
+               printk(KERN_DEBUG "%s: failed to insert STA entry for"
+                      " the AP (error %d)\n", sdata->name, err);
+               return false;
        }
 
-       rcu_read_unlock();
-
        if (elems.wmm_param)
                ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
                                         elems.wmm_param_len);
        else
                ieee80211_set_wmm_default(sdata);
 
+       local->oper_channel = wk->chan;
+
        if (elems.ht_info_elem && elems.wmm_param &&
-           (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
+           (sdata->local->hw.queues >= 4) &&
            !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
                changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
-                                              wk->bss->cbss.bssid,
-                                              ap_ht_cap_flags);
-
-        /* delete work item -- must be before set_associated for PS */
-       list_del(&wk->list);
+                                              cbss->bssid, ap_ht_cap_flags);
 
        /* set AID and assoc capability,
         * ieee80211_set_associated() will tell the driver */
        bss_conf->aid = aid;
        bss_conf->assoc_capability = capab_info;
-       /* this will take ownership of wk */
-       ieee80211_set_associated(sdata, wk, changed);
+       ieee80211_set_associated(sdata, cbss, changed);
+
+       /*
+        * If we're using 4-addr mode, let the AP know that we're
+        * doing so, so that it can create the STA VLAN on its side
+        */
+       if (ifmgd->use_4addr)
+               ieee80211_send_4addr_nullfunc(local, sdata);
 
        /*
         * Start timer to probe the connection to the AP now.
@@ -1622,7 +1153,7 @@ ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
        ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
        mod_beacon_timer(sdata);
 
-       return RX_MGMT_CFG80211_ASSOC;
+       return true;
 }
 
 
@@ -1657,7 +1188,7 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
                return;
 
        if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
-           (memcmp(mgmt->bssid, sdata->u.mgd.associated->cbss.bssid,
+           (memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid,
                                                        ETH_ALEN) == 0)) {
                struct ieee80211_channel_sw_ie *sw_elem =
                        (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
@@ -1667,19 +1198,19 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
 
 
 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
-                                        struct ieee80211_mgd_work *wk,
-                                        struct ieee80211_mgmt *mgmt, size_t len,
-                                        struct ieee80211_rx_status *rx_status)
+                                        struct sk_buff *skb)
 {
+       struct ieee80211_mgmt *mgmt = (void *)skb->data;
        struct ieee80211_if_managed *ifmgd;
-       size_t baselen;
+       struct ieee80211_rx_status *rx_status = (void *) skb->cb;
+       size_t baselen, len = skb->len;
        struct ieee802_11_elems elems;
 
        ifmgd = &sdata->u.mgd;
 
        ASSERT_MGD_MTX(ifmgd);
 
-       if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
+       if (memcmp(mgmt->da, sdata->vif.addr, ETH_ALEN))
                return; /* ignore ProbeResp to foreign address */
 
        baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
@@ -1691,17 +1222,8 @@ static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
 
        ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
 
-       /* direct probe may be part of the association flow */
-       if (wk && wk->state == IEEE80211_MGD_STATE_PROBE) {
-               printk(KERN_DEBUG "%s: direct probe responded\n",
-                      sdata->dev->name);
-               wk->tries = 0;
-               wk->state = IEEE80211_MGD_STATE_AUTH;
-               WARN_ON(ieee80211_authenticate(sdata, wk) != RX_MGMT_NONE);
-       }
-
        if (ifmgd->associated &&
-           memcmp(mgmt->bssid, ifmgd->associated->cbss.bssid, ETH_ALEN) == 0 &&
+           memcmp(mgmt->bssid, ifmgd->associated->bssid, ETH_ALEN) == 0 &&
            ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
                            IEEE80211_STA_CONNECTION_POLL)) {
                ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
@@ -1774,7 +1296,7 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
        if (!ifmgd->associated)
                return;
 
-       bssid = ifmgd->associated->cbss.bssid;
+       bssid = ifmgd->associated->bssid;
 
        /*
         * And in theory even frames from a different AP we were just
@@ -1787,7 +1309,7 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
                if (net_ratelimit()) {
                        printk(KERN_DEBUG "%s: cancelling probereq poll due "
-                              "to a received beacon\n", sdata->dev->name);
+                              "to a received beacon\n", sdata->name);
                }
 #endif
                ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
@@ -1865,7 +1387,7 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
 
                rcu_read_lock();
 
-               sta = sta_info_get(local, bssid);
+               sta = sta_info_get(sdata, bssid);
                if (WARN_ON(!sta)) {
                        rcu_read_unlock();
                        return;
@@ -1913,9 +1435,6 @@ ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
        switch (fc & IEEE80211_FCTL_STYPE) {
        case IEEE80211_STYPE_PROBE_RESP:
        case IEEE80211_STYPE_BEACON:
-       case IEEE80211_STYPE_AUTH:
-       case IEEE80211_STYPE_ASSOC_RESP:
-       case IEEE80211_STYPE_REASSOC_RESP:
        case IEEE80211_STYPE_DEAUTH:
        case IEEE80211_STYPE_DISASSOC:
        case IEEE80211_STYPE_ACTION:
@@ -1933,7 +1452,6 @@ static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        struct ieee80211_rx_status *rx_status;
        struct ieee80211_mgmt *mgmt;
-       struct ieee80211_mgd_work *wk;
        enum rx_mgmt_action rma = RX_MGMT_NONE;
        u16 fc;
 
@@ -1944,20 +1462,17 @@ static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
        mutex_lock(&ifmgd->mtx);
 
        if (ifmgd->associated &&
-           memcmp(ifmgd->associated->cbss.bssid, mgmt->bssid,
-                                                       ETH_ALEN) == 0) {
+           memcmp(ifmgd->associated->bssid, mgmt->bssid, ETH_ALEN) == 0) {
                switch (fc & IEEE80211_FCTL_STYPE) {
                case IEEE80211_STYPE_BEACON:
                        ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
                                                 rx_status);
                        break;
                case IEEE80211_STYPE_PROBE_RESP:
-                       ieee80211_rx_mgmt_probe_resp(sdata, NULL, mgmt,
-                                                    skb->len, rx_status);
+                       ieee80211_rx_mgmt_probe_resp(sdata, skb);
                        break;
                case IEEE80211_STYPE_DEAUTH:
-                       rma = ieee80211_rx_mgmt_deauth(sdata, NULL,
-                                                      mgmt, skb->len);
+                       rma = ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
                        break;
                case IEEE80211_STYPE_DISASSOC:
                        rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
@@ -1968,7 +1483,7 @@ static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
 
                        ieee80211_sta_process_chanswitch(sdata,
                                        &mgmt->u.action.u.chan_switch.sw_elem,
-                                       ifmgd->associated);
+                                       (void *)ifmgd->associated->priv);
                        break;
                }
                mutex_unlock(&ifmgd->mtx);
@@ -1989,58 +1504,11 @@ static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
                goto out;
        }
 
-       list_for_each_entry(wk, &ifmgd->work_list, list) {
-               if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
-                       continue;
-
-               switch (fc & IEEE80211_FCTL_STYPE) {
-               case IEEE80211_STYPE_PROBE_RESP:
-                       ieee80211_rx_mgmt_probe_resp(sdata, wk, mgmt, skb->len,
-                                                    rx_status);
-                       break;
-               case IEEE80211_STYPE_AUTH:
-                       rma = ieee80211_rx_mgmt_auth(sdata, wk, mgmt, skb->len);
-                       break;
-               case IEEE80211_STYPE_ASSOC_RESP:
-                       rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
-                                                          skb->len, false);
-                       break;
-               case IEEE80211_STYPE_REASSOC_RESP:
-                       rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
-                                                          skb->len, true);
-                       break;
-               case IEEE80211_STYPE_DEAUTH:
-                       rma = ieee80211_rx_mgmt_deauth(sdata, wk, mgmt,
-                                                      skb->len);
-                       break;
-               }
-               /*
-                * We've processed this frame for that work, so it can't
-                * belong to another work struct.
-                * NB: this is also required for correctness because the
-                * called functions can free 'wk', and for 'rma'!
-                */
-               break;
-       }
-
        mutex_unlock(&ifmgd->mtx);
 
-       switch (rma) {
-       case RX_MGMT_NONE:
-               /* no action */
-               break;
-       case RX_MGMT_CFG80211_AUTH:
-               cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, skb->len);
-               break;
-       case RX_MGMT_CFG80211_ASSOC:
-               cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, skb->len);
-               break;
-       case RX_MGMT_CFG80211_DEAUTH:
+       if (skb->len >= 24 + 2 /* mgmt + deauth reason */ &&
+           (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_DEAUTH)
                cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
-               break;
-       default:
-               WARN(1, "unexpected: %d", rma);
-       }
 
  out:
        kfree_skb(skb);
@@ -2068,12 +1536,8 @@ static void ieee80211_sta_work(struct work_struct *work)
        struct ieee80211_local *local = sdata->local;
        struct ieee80211_if_managed *ifmgd;
        struct sk_buff *skb;
-       struct ieee80211_mgd_work *wk, *tmp;
-       LIST_HEAD(free_work);
-       enum rx_mgmt_action rma;
-       bool anybusy = false;
 
-       if (!netif_running(sdata->dev))
+       if (!ieee80211_sdata_running(sdata))
                return;
 
        if (local->scanning)
@@ -2104,7 +1568,7 @@ static void ieee80211_sta_work(struct work_struct *work)
            ifmgd->associated) {
                u8 bssid[ETH_ALEN];
 
-               memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
+               memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
                if (time_is_after_jiffies(ifmgd->probe_timeout))
                        run_again(ifmgd, ifmgd->probe_timeout);
 
@@ -2126,7 +1590,7 @@ static void ieee80211_sta_work(struct work_struct *work)
                        printk(KERN_DEBUG "No probe response from AP %pM"
                                " after %dms, disconnecting.\n",
                                bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);
-                       ieee80211_set_disassoc(sdata, true);
+                       ieee80211_set_disassoc(sdata);
                        ieee80211_recalc_idle(local);
                        mutex_unlock(&ifmgd->mtx);
                        /*
@@ -2141,87 +1605,7 @@ static void ieee80211_sta_work(struct work_struct *work)
                }
        }
 
-
-       ieee80211_recalc_idle(local);
-
-       list_for_each_entry_safe(wk, tmp, &ifmgd->work_list, list) {
-               if (time_is_after_jiffies(wk->timeout)) {
-                       /*
-                        * This work item isn't supposed to be worked on
-                        * right now, but take care to adjust the timer
-                        * properly.
-                        */
-                       run_again(ifmgd, wk->timeout);
-                       continue;
-               }
-
-               switch (wk->state) {
-               default:
-                       WARN_ON(1);
-                       /* fall through */
-               case IEEE80211_MGD_STATE_IDLE:
-                       /* nothing */
-                       rma = RX_MGMT_NONE;
-                       break;
-               case IEEE80211_MGD_STATE_PROBE:
-                       rma = ieee80211_direct_probe(sdata, wk);
-                       break;
-               case IEEE80211_MGD_STATE_AUTH:
-                       rma = ieee80211_authenticate(sdata, wk);
-                       break;
-               case IEEE80211_MGD_STATE_ASSOC:
-                       rma = ieee80211_associate(sdata, wk);
-                       break;
-               }
-
-               switch (rma) {
-               case RX_MGMT_NONE:
-                       /* no action required */
-                       break;
-               case RX_MGMT_CFG80211_AUTH_TO:
-               case RX_MGMT_CFG80211_ASSOC_TO:
-                       list_del(&wk->list);
-                       list_add(&wk->list, &free_work);
-                       wk->tries = rma; /* small abuse but only local */
-                       break;
-               default:
-                       WARN(1, "unexpected: %d", rma);
-               }
-       }
-
-       list_for_each_entry(wk, &ifmgd->work_list, list) {
-               if (wk->state != IEEE80211_MGD_STATE_IDLE) {
-                       anybusy = true;
-                       break;
-               }
-       }
-       if (!anybusy &&
-           test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request))
-               ieee80211_queue_delayed_work(&local->hw,
-                                            &local->scan_work,
-                                            round_jiffies_relative(0));
-
        mutex_unlock(&ifmgd->mtx);
-
-       list_for_each_entry_safe(wk, tmp, &free_work, list) {
-               switch (wk->tries) {
-               case RX_MGMT_CFG80211_AUTH_TO:
-                       cfg80211_send_auth_timeout(sdata->dev,
-                                                  wk->bss->cbss.bssid);
-                       break;
-               case RX_MGMT_CFG80211_ASSOC_TO:
-                       cfg80211_send_assoc_timeout(sdata->dev,
-                                                   wk->bss->cbss.bssid);
-                       break;
-               default:
-                       WARN(1, "unexpected: %d", wk->tries);
-               }
-
-               list_del(&wk->list);
-               kfree(wk);
-       }
-
-       ieee80211_recalc_idle(local);
 }
 
 static void ieee80211_sta_bcn_mon_timer(unsigned long data)
@@ -2330,14 +1714,14 @@ void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
                    (unsigned long) sdata);
        skb_queue_head_init(&ifmgd->skb_queue);
 
-       INIT_LIST_HEAD(&ifmgd->work_list);
-
-       ifmgd->capab = WLAN_CAPABILITY_ESS;
        ifmgd->flags = 0;
-       if (sdata->local->hw.queues >= 4)
-               ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;
 
        mutex_init(&ifmgd->mtx);
+
+       if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS)
+               ifmgd->req_smps = IEEE80211_SMPS_AUTOMATIC;
+       else
+               ifmgd->req_smps = IEEE80211_SMPS_OFF;
 }
 
 /* scan finished notification */
@@ -2368,12 +1752,34 @@ int ieee80211_max_network_latency(struct notifier_block *nb,
 }
 
 /* config hooks */
+static enum work_done_result
+ieee80211_probe_auth_done(struct ieee80211_work *wk,
+                         struct sk_buff *skb)
+{
+       if (!skb) {
+               cfg80211_send_auth_timeout(wk->sdata->dev, wk->filter_ta);
+               return WORK_DONE_DESTROY;
+       }
+
+       if (wk->type == IEEE80211_WORK_AUTH) {
+               cfg80211_send_rx_auth(wk->sdata->dev, skb->data, skb->len);
+               return WORK_DONE_DESTROY;
+       }
+
+       mutex_lock(&wk->sdata->u.mgd.mtx);
+       ieee80211_rx_mgmt_probe_resp(wk->sdata, skb);
+       mutex_unlock(&wk->sdata->u.mgd.mtx);
+
+       wk->type = IEEE80211_WORK_AUTH;
+       wk->probe_auth.tries = 0;
+       return WORK_DONE_REQUEUE;
+}
+
 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
                       struct cfg80211_auth_request *req)
 {
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
        const u8 *ssid;
-       struct ieee80211_mgd_work *wk;
+       struct ieee80211_work *wk;
        u16 auth_alg;
 
        switch (req->auth_type) {
@@ -2397,7 +1803,7 @@ int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
        if (!wk)
                return -ENOMEM;
 
-       wk->bss = (void *)req->bss;
+       memcpy(wk->filter_ta, req->bss->bssid, ETH_ALEN);
 
        if (req->ie && req->ie_len) {
                memcpy(wk->ie, req->ie, req->ie_len);
@@ -2405,66 +1811,76 @@ int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
        }
 
        if (req->key && req->key_len) {
-               wk->key_len = req->key_len;
-               wk->key_idx = req->key_idx;
-               memcpy(wk->key, req->key, req->key_len);
+               wk->probe_auth.key_len = req->key_len;
+               wk->probe_auth.key_idx = req->key_idx;
+               memcpy(wk->probe_auth.key, req->key, req->key_len);
        }
 
        ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
-       memcpy(wk->ssid, ssid + 2, ssid[1]);
-       wk->ssid_len = ssid[1];
+       memcpy(wk->probe_auth.ssid, ssid + 2, ssid[1]);
+       wk->probe_auth.ssid_len = ssid[1];
 
-       wk->state = IEEE80211_MGD_STATE_PROBE;
-       wk->auth_alg = auth_alg;
-       wk->timeout = jiffies; /* run right away */
+       wk->probe_auth.algorithm = auth_alg;
+       wk->probe_auth.privacy = req->bss->capability & WLAN_CAPABILITY_PRIVACY;
 
-       /*
-        * XXX: if still associated need to tell AP that we're going
-        *      to sleep and then change channel etc.
-        */
-       sdata->local->oper_channel = req->bss->channel;
-       ieee80211_hw_config(sdata->local, 0);
-
-       mutex_lock(&ifmgd->mtx);
-       list_add(&wk->list, &sdata->u.mgd.work_list);
-       mutex_unlock(&ifmgd->mtx);
+       wk->type = IEEE80211_WORK_DIRECT_PROBE;
+       wk->chan = req->bss->channel;
+       wk->sdata = sdata;
+       wk->done = ieee80211_probe_auth_done;
 
-       ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
+       ieee80211_add_work(wk);
        return 0;
 }
 
-int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
-                       struct cfg80211_assoc_request *req)
+static enum work_done_result ieee80211_assoc_done(struct ieee80211_work *wk,
+                                                 struct sk_buff *skb)
 {
-       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-       struct ieee80211_mgd_work *wk, *found = NULL;
-       int i, err;
+       struct ieee80211_mgmt *mgmt;
+       u16 status;
 
-       mutex_lock(&ifmgd->mtx);
+       if (!skb) {
+               cfg80211_send_assoc_timeout(wk->sdata->dev, wk->filter_ta);
+               return WORK_DONE_DESTROY;
+       }
 
-       list_for_each_entry(wk, &ifmgd->work_list, list) {
-               if (&wk->bss->cbss == req->bss &&
-                   wk->state == IEEE80211_MGD_STATE_IDLE) {
-                       found = wk;
-                       break;
+       mgmt = (void *)skb->data;
+       status = le16_to_cpu(mgmt->u.assoc_resp.status_code);
+
+       if (status == WLAN_STATUS_SUCCESS) {
+               mutex_lock(&wk->sdata->u.mgd.mtx);
+               if (!ieee80211_assoc_success(wk, mgmt, skb->len)) {
+                       mutex_unlock(&wk->sdata->u.mgd.mtx);
+                       /* oops -- internal error -- send timeout for now */
+                       cfg80211_send_assoc_timeout(wk->sdata->dev,
+                                                   wk->filter_ta);
+                       return WORK_DONE_DESTROY;
                }
+               mutex_unlock(&wk->sdata->u.mgd.mtx);
        }
 
-       if (!found) {
-               err = -ENOLINK;
-               goto out;
-       }
+       cfg80211_send_rx_assoc(wk->sdata->dev, skb->data, skb->len);
+       return WORK_DONE_DESTROY;
+}
 
-       list_del(&found->list);
+int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
+                       struct cfg80211_assoc_request *req)
+{
+       struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+       struct ieee80211_bss *bss = (void *)req->bss->priv;
+       struct ieee80211_work *wk;
+       const u8 *ssid;
+       int i;
 
-       wk = krealloc(found, sizeof(*wk) + req->ie_len, GFP_KERNEL);
-       if (!wk) {
-               list_add(&found->list, &ifmgd->work_list);
-               err = -ENOMEM;
-               goto out;
+       mutex_lock(&ifmgd->mtx);
+       if (ifmgd->associated) {
+               mutex_unlock(&ifmgd->mtx);
+               return -EALREADY;
        }
+       mutex_unlock(&ifmgd->mtx);
 
-       list_add(&wk->list, &ifmgd->work_list);
+       wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);
+       if (!wk)
+               return -ENOMEM;
 
        ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
 
@@ -2474,8 +1890,6 @@ int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
                    req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)
                        ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
 
-       sdata->local->oper_channel = req->bss->channel;
-       ieee80211_hw_config(sdata->local, 0);
 
        if (req->ie && req->ie_len) {
                memcpy(wk->ie, req->ie, req->ie_len);
@@ -2483,12 +1897,55 @@ int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
        } else
                wk->ie_len = 0;
 
+       wk->assoc.bss = req->bss;
+
+       memcpy(wk->filter_ta, req->bss->bssid, ETH_ALEN);
+
+       /* new association always uses requested smps mode */
+       if (ifmgd->req_smps == IEEE80211_SMPS_AUTOMATIC) {
+               if (ifmgd->powersave)
+                       ifmgd->ap_smps = IEEE80211_SMPS_DYNAMIC;
+               else
+                       ifmgd->ap_smps = IEEE80211_SMPS_OFF;
+       } else
+               ifmgd->ap_smps = ifmgd->req_smps;
+
+       wk->assoc.smps = ifmgd->ap_smps;
+       /*
+        * IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode.
+        * We still associate in non-HT mode (11a/b/g) if any one of these
+        * ciphers is configured as pairwise.
+        * We can set this to true for non-11n hardware, that'll be checked
+        * separately along with the peer capabilities.
+        */
+       wk->assoc.use_11n = !(ifmgd->flags & IEEE80211_STA_DISABLE_11N);
+       wk->assoc.capability = req->bss->capability;
+       wk->assoc.wmm_used = bss->wmm_used;
+       wk->assoc.supp_rates = bss->supp_rates;
+       wk->assoc.supp_rates_len = bss->supp_rates_len;
+       wk->assoc.ht_information_ie =
+               ieee80211_bss_get_ie(req->bss, WLAN_EID_HT_INFORMATION);
+
+       if (bss->wmm_used && bss->uapsd_supported &&
+           (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) {
+               wk->assoc.uapsd_used = true;
+               ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED;
+       } else {
+               wk->assoc.uapsd_used = false;
+               ifmgd->flags &= ~IEEE80211_STA_UAPSD_ENABLED;
+       }
+
+       ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
+       memcpy(wk->assoc.ssid, ssid + 2, ssid[1]);
+       wk->assoc.ssid_len = ssid[1];
+
        if (req->prev_bssid)
-               memcpy(wk->prev_bssid, req->prev_bssid, ETH_ALEN);
+               memcpy(wk->assoc.prev_bssid, req->prev_bssid, ETH_ALEN);
 
-       wk->state = IEEE80211_MGD_STATE_ASSOC;
-       wk->tries = 0;
-       wk->timeout = jiffies; /* run right away */
+       wk->type = IEEE80211_WORK_ASSOC;
+       wk->chan = req->bss->channel;
+       wk->sdata = sdata;
+       wk->done = ieee80211_assoc_done;
 
        if (req->use_mfp) {
                ifmgd->mfp = IEEE80211_MFP_REQUIRED;
@@ -2503,69 +1960,59 @@ int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
        else
                ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
 
-       ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
-
-       err = 0;
-
- out:
-       mutex_unlock(&ifmgd->mtx);
-       return err;
+       ieee80211_add_work(wk);
+       return 0;
 }
 
 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
                         struct cfg80211_deauth_request *req,
                         void *cookie)
 {
+       struct ieee80211_local *local = sdata->local;
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
-       struct ieee80211_mgd_work *wk;
-       const u8 *bssid = NULL;
-       bool not_auth_yet = false;
+       struct ieee80211_work *wk;
+       const u8 *bssid = req->bss->bssid;
 
        mutex_lock(&ifmgd->mtx);
 
-       if (ifmgd->associated && &ifmgd->associated->cbss == req->bss) {
+       if (ifmgd->associated == req->bss) {
                bssid = req->bss->bssid;
-               ieee80211_set_disassoc(sdata, true);
-       } else list_for_each_entry(wk, &ifmgd->work_list, list) {
-               if (&wk->bss->cbss == req->bss) {
-                       bssid = req->bss->bssid;
-                       if (wk->state == IEEE80211_MGD_STATE_PROBE)
-                               not_auth_yet = true;
+               ieee80211_set_disassoc(sdata);
+               mutex_unlock(&ifmgd->mtx);
+       } else {
+               bool not_auth_yet = false;
+
+               mutex_unlock(&ifmgd->mtx);
+
+               mutex_lock(&local->work_mtx);
+               list_for_each_entry(wk, &local->work_list, list) {
+                       if (wk->type != IEEE80211_WORK_DIRECT_PROBE)
+                               continue;
+                       if (memcmp(req->bss->bssid, wk->filter_ta, ETH_ALEN))
+                               continue;
+                       not_auth_yet = true;
                        list_del(&wk->list);
-                       kfree(wk);
+                       free_work(wk);
                        break;
                }
-       }
-
-       /*
-        * If somebody requests authentication and we haven't
-        * sent out an auth frame yet there's no need to send
-        * out a deauth frame either. If the state was PROBE,
-        * then this is the case. If it's AUTH we have sent a
-        * frame, and if it's IDLE we have completed the auth
-        * process already.
-        */
-       if (not_auth_yet) {
-               mutex_unlock(&ifmgd->mtx);
-               __cfg80211_auth_canceled(sdata->dev, bssid);
-               return 0;
-       }
+               mutex_unlock(&local->work_mtx);
 
-       /*
-        * cfg80211 should catch this ... but it's racy since
-        * we can receive a deauth frame, process it, hand it
-        * to cfg80211 while that's in a locked section already
-        * trying to tell us that the user wants to disconnect.
-        */
-       if (!bssid) {
-               mutex_unlock(&ifmgd->mtx);
-               return -ENOLINK;
+               /*
+                * If somebody requests authentication and we haven't
+                * sent out an auth frame yet there's no need to send
+                * out a deauth frame either. If the state was PROBE,
+                * then this is the case. If it's AUTH we have sent a
+                * frame, and if it's IDLE we have completed the auth
+                * process already.
+                */
+               if (not_auth_yet) {
+                       __cfg80211_auth_canceled(sdata->dev, bssid);
+                       return 0;
+               }
        }
 
-       mutex_unlock(&ifmgd->mtx);
-
        printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n",
-              sdata->dev->name, bssid, req->reason_code);
+              sdata->name, bssid, req->reason_code);
 
        ieee80211_send_deauth_disassoc(sdata, bssid,
                        IEEE80211_STYPE_DEAUTH, req->reason_code,
@@ -2590,15 +2037,15 @@ int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
         * to cfg80211 while that's in a locked section already
         * trying to tell us that the user wants to disconnect.
         */
-       if (&ifmgd->associated->cbss != req->bss) {
+       if (ifmgd->associated != req->bss) {
                mutex_unlock(&ifmgd->mtx);
                return -ENOLINK;
        }
 
        printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
-              sdata->dev->name, req->bss->bssid, req->reason_code);
+              sdata->name, req->bss->bssid, req->reason_code);
 
-       ieee80211_set_disassoc(sdata, false);
+       ieee80211_set_disassoc(sdata);
 
        mutex_unlock(&ifmgd->mtx);