1 files changed, 221 insertions, 161 deletions

diff --git a/drivers/net/wireless/wl12xx/tx.c b/drivers/net/wireless/wl12xx/tx.c
index bad9e29d49b0..4508ccd78328 100644
--- a/drivers/net/wireless/wl12xx/tx.c
+++ b/drivers/net/wireless/wl12xx/tx.c
@@ -26,22 +26,24 @@
 #include <linux/etherdevice.h>
 
 #include "wl12xx.h"
+#include "debug.h"
 #include "io.h"
 #include "reg.h"
 #include "ps.h"
 #include "tx.h"
 #include "event.h"
 
-static int wl1271_set_default_wep_key(struct wl1271 *wl, u8 id)
+static int wl1271_set_default_wep_key(struct wl1271 *wl,
+                                      struct wl12xx_vif *wlvif, u8 id)
 {
         int ret;
-        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+        bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
 
         if (is_ap)
                 ret = wl12xx_cmd_set_default_wep_key(wl, id,
-                                                     wl->ap_bcast_hlid);
+                                                     wlvif->ap.bcast_hlid);
         else
-                ret = wl12xx_cmd_set_default_wep_key(wl, id, wl->sta_hlid);
+                ret = wl12xx_cmd_set_default_wep_key(wl, id, wlvif->sta.hlid);
 
         if (ret < 0)
                 return ret;
@@ -76,7 +78,8 @@ static void wl1271_free_tx_id(struct wl1271 *wl, int id)
 }
 
 static int wl1271_tx_update_filters(struct wl1271 *wl,
-                                                 struct sk_buff *skb)
+                                    struct wl12xx_vif *wlvif,
+                                    struct sk_buff *skb)
 {
         struct ieee80211_hdr *hdr;
         int ret;
@@ -92,15 +95,11 @@ static int wl1271_tx_update_filters(struct wl1271 *wl,
         if (!ieee80211_is_auth(hdr->frame_control))
                 return 0;
 
-        if (wl->dev_hlid != WL12XX_INVALID_LINK_ID)
+        if (wlvif->dev_hlid != WL12XX_INVALID_LINK_ID)
                 goto out;
 
         wl1271_debug(DEBUG_CMD, "starting device role for roaming");
-        ret = wl12xx_cmd_role_start_dev(wl);
-        if (ret < 0)
-                goto out;
-
-        ret = wl12xx_roc(wl, wl->dev_role_id);
+        ret = wl12xx_start_dev(wl, wlvif);
         if (ret < 0)
                 goto out;
 out:
@@ -123,18 +122,16 @@ static void wl1271_tx_ap_update_inconnection_sta(struct wl1271 *wl,
                 wl1271_acx_set_inconnection_sta(wl, hdr->addr1);
 }
 
-static void wl1271_tx_regulate_link(struct wl1271 *wl, u8 hlid)
+static void wl1271_tx_regulate_link(struct wl1271 *wl,
+                                    struct wl12xx_vif *wlvif,
+                                    u8 hlid)
 {
         bool fw_ps, single_sta;
         u8 tx_pkts;
 
-        /* only regulate station links */
-        if (hlid < WL1271_AP_STA_HLID_START)
+        if (WARN_ON(!test_bit(hlid, wlvif->links_map)))
                 return;
 
-        if (WARN_ON(!wl1271_is_active_sta(wl, hlid)))
-            return;
-
         fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
         tx_pkts = wl->links[hlid].allocated_pkts;
         single_sta = (wl->active_sta_count == 1);
@@ -146,7 +143,7 @@ static void wl1271_tx_regulate_link(struct wl1271 *wl, u8 hlid)
          * case FW-memory congestion is not a problem.
          */
         if (!single_sta && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
-                wl1271_ps_link_start(wl, hlid, true);
+                wl12xx_ps_link_start(wl, wlvif, hlid, true);
 }
 
 bool wl12xx_is_dummy_packet(struct wl1271 *wl, struct sk_buff *skb)
@@ -154,7 +151,8 @@ bool wl12xx_is_dummy_packet(struct wl1271 *wl, struct sk_buff *skb)
         return wl->dummy_packet == skb;
 }
 
-u8 wl12xx_tx_get_hlid_ap(struct wl1271 *wl, struct sk_buff *skb)
+u8 wl12xx_tx_get_hlid_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif,
+                         struct sk_buff *skb)
 {
         struct ieee80211_tx_info *control = IEEE80211_SKB_CB(skb);
 
@@ -167,49 +165,51 @@ u8 wl12xx_tx_get_hlid_ap(struct wl1271 *wl, struct sk_buff *skb)
         } else {
                 struct ieee80211_hdr *hdr;
 
-                if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
+                if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
                         return wl->system_hlid;
 
                 hdr = (struct ieee80211_hdr *)skb->data;
                 if (ieee80211_is_mgmt(hdr->frame_control))
-                        return wl->ap_global_hlid;
+                        return wlvif->ap.global_hlid;
                 else
-                        return wl->ap_bcast_hlid;
+                        return wlvif->ap.bcast_hlid;
         }
 }
 
-static u8 wl1271_tx_get_hlid(struct wl1271 *wl, struct sk_buff *skb)
+u8 wl12xx_tx_get_hlid(struct wl1271 *wl, struct wl12xx_vif *wlvif,
+                      struct sk_buff *skb)
 {
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 
-        if (wl12xx_is_dummy_packet(wl, skb))
+        if (!wlvif || wl12xx_is_dummy_packet(wl, skb))
                 return wl->system_hlid;
 
-        if (wl->bss_type == BSS_TYPE_AP_BSS)
-                return wl12xx_tx_get_hlid_ap(wl, skb);
+        if (wlvif->bss_type == BSS_TYPE_AP_BSS)
+                return wl12xx_tx_get_hlid_ap(wl, wlvif, skb);
 
-        wl1271_tx_update_filters(wl, skb);
+        wl1271_tx_update_filters(wl, wlvif, skb);
 
-        if ((test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
-             test_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags)) &&
+        if ((test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
+             test_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags)) &&
             !ieee80211_is_auth(hdr->frame_control) &&
             !ieee80211_is_assoc_req(hdr->frame_control))
-                return wl->sta_hlid;
+                return wlvif->sta.hlid;
         else
-                return wl->dev_hlid;
+                return wlvif->dev_hlid;
 }
 
 static unsigned int wl12xx_calc_packet_alignment(struct wl1271 *wl,
                                                 unsigned int packet_length)
 {
-        if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT)
-                return ALIGN(packet_length, WL12XX_BUS_BLOCK_SIZE);
-        else
+        if (wl->quirks & WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT)
                 return ALIGN(packet_length, WL1271_TX_ALIGN_TO);
+        else
+                return ALIGN(packet_length, WL12XX_BUS_BLOCK_SIZE);
 }
 
-static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
-                                u32 buf_offset, u8 hlid)
+static int wl1271_tx_allocate(struct wl1271 *wl, struct wl12xx_vif *wlvif,
+                              struct sk_buff *skb, u32 extra, u32 buf_offset,
+                              u8 hlid)
 {
         struct wl1271_tx_hw_descr *desc;
         u32 total_len = skb->len + sizeof(struct wl1271_tx_hw_descr) + extra;
@@ -217,6 +217,7 @@ static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
         u32 total_blocks;
         int id, ret = -EBUSY, ac;
         u32 spare_blocks = wl->tx_spare_blocks;
+        bool is_dummy = false;
 
         if (buf_offset + total_len > WL1271_AGGR_BUFFER_SIZE)
                 return -EAGAIN;
@@ -231,8 +232,10 @@ static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
         len = wl12xx_calc_packet_alignment(wl, total_len);
 
         /* in case of a dummy packet, use default amount of spare mem blocks */
-        if (unlikely(wl12xx_is_dummy_packet(wl, skb)))
+        if (unlikely(wl12xx_is_dummy_packet(wl, skb))) {
+                is_dummy = true;
                 spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
+        }
 
         total_blocks = (len + TX_HW_BLOCK_SIZE - 1) / TX_HW_BLOCK_SIZE +
                 spare_blocks;
@@ -257,8 +260,9 @@ static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
                 ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
                 wl->tx_allocated_pkts[ac]++;
 
-                if (wl->bss_type == BSS_TYPE_AP_BSS &&
-                    hlid >= WL1271_AP_STA_HLID_START)
+                if (!is_dummy && wlvif &&
+                    wlvif->bss_type == BSS_TYPE_AP_BSS &&
+                    test_bit(hlid, wlvif->ap.sta_hlid_map))
                         wl->links[hlid].allocated_pkts++;
 
                 ret = 0;
@@ -273,15 +277,16 @@ static int wl1271_tx_allocate(struct wl1271 *wl, struct sk_buff *skb, u32 extra,
         return ret;
 }
 
-static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
-                              u32 extra, struct ieee80211_tx_info *control,
-                              u8 hlid)
+static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct wl12xx_vif *wlvif,
+                               struct sk_buff *skb, u32 extra,
+                               struct ieee80211_tx_info *control, u8 hlid)
 {
         struct timespec ts;
         struct wl1271_tx_hw_descr *desc;
         int aligned_len, ac, rate_idx;
         s64 hosttime;
-        u16 tx_attr;
+        u16 tx_attr = 0;
+        bool is_dummy;
 
         desc = (struct wl1271_tx_hw_descr *) skb->data;
 
@@ -298,7 +303,8 @@ static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
         hosttime = (timespec_to_ns(&ts) >> 10);
         desc->start_time = cpu_to_le32(hosttime - wl->time_offset);
 
-        if (wl->bss_type != BSS_TYPE_AP_BSS)
+        is_dummy = wl12xx_is_dummy_packet(wl, skb);
+        if (is_dummy || !wlvif || wlvif->bss_type != BSS_TYPE_AP_BSS)
                 desc->life_time = cpu_to_le16(TX_HW_MGMT_PKT_LIFETIME_TU);
         else
                 desc->life_time = cpu_to_le16(TX_HW_AP_MODE_PKT_LIFETIME_TU);
@@ -307,39 +313,42 @@ static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
         ac = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
         desc->tid = skb->priority;
 
-        if (wl12xx_is_dummy_packet(wl, skb)) {
+        if (is_dummy) {
                 /*
                  * FW expects the dummy packet to have an invalid session id -
                  * any session id that is different than the one set in the join
                  */
-                tx_attr = ((~wl->session_counter) <<
+                tx_attr = (SESSION_COUNTER_INVALID <<
                            TX_HW_ATTR_OFST_SESSION_COUNTER) &
                            TX_HW_ATTR_SESSION_COUNTER;
 
                 tx_attr |= TX_HW_ATTR_TX_DUMMY_REQ;
-        } else {
+        } else if (wlvif) {
                 /* configure the tx attributes */
-                tx_attr =
-                        wl->session_counter << TX_HW_ATTR_OFST_SESSION_COUNTER;
+                tx_attr = wlvif->session_counter <<
+                          TX_HW_ATTR_OFST_SESSION_COUNTER;
         }
 
         desc->hlid = hlid;
-
-        if (wl->bss_type != BSS_TYPE_AP_BSS) {
+        if (is_dummy || !wlvif)
+                rate_idx = 0;
+        else if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
                 /* if the packets are destined for AP (have a STA entry)
                    send them with AP rate policies, otherwise use default
                    basic rates */
-                if (control->control.sta)
-                        rate_idx = ACX_TX_AP_FULL_RATE;
+                if (control->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
+                        rate_idx = wlvif->sta.p2p_rate_idx;
+                else if (control->control.sta)
+                        rate_idx = wlvif->sta.ap_rate_idx;
                 else
-                        rate_idx = ACX_TX_BASIC_RATE;
+                        rate_idx = wlvif->sta.basic_rate_idx;
         } else {
-                if (hlid == wl->ap_global_hlid)
-                        rate_idx = ACX_TX_AP_MODE_MGMT_RATE;
-                else if (hlid == wl->ap_bcast_hlid)
-                        rate_idx = ACX_TX_AP_MODE_BCST_RATE;
+                if (hlid == wlvif->ap.global_hlid)
+                        rate_idx = wlvif->ap.mgmt_rate_idx;
+                else if (hlid == wlvif->ap.bcast_hlid)
+                        rate_idx = wlvif->ap.bcast_rate_idx;
                 else
-                        rate_idx = ac;
+                        rate_idx = wlvif->ap.ucast_rate_idx[ac];
         }
 
         tx_attr |= rate_idx << TX_HW_ATTR_OFST_RATE_POLICY;
@@ -379,20 +388,24 @@ static void wl1271_tx_fill_hdr(struct wl1271 *wl, struct sk_buff *skb,
 }
 
 /* caller must hold wl->mutex */
-static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct sk_buff *skb,
-                                                        u32 buf_offset)
+static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct wl12xx_vif *wlvif,
+                                   struct sk_buff *skb, u32 buf_offset)
 {
         struct ieee80211_tx_info *info;
         u32 extra = 0;
         int ret = 0;
         u32 total_len;
         u8 hlid;
+        bool is_dummy;
 
         if (!skb)
                 return -EINVAL;
 
         info = IEEE80211_SKB_CB(skb);
 
+        /* TODO: handle dummy packets on multi-vifs */
+        is_dummy = wl12xx_is_dummy_packet(wl, skb);
+
         if (info->control.hw_key &&
             info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP)
                 extra = WL1271_TKIP_IV_SPACE;
@@ -405,29 +418,28 @@ static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct sk_buff *skb,
                 is_wep = (cipher == WLAN_CIPHER_SUITE_WEP40) ||
                          (cipher == WLAN_CIPHER_SUITE_WEP104);
 
-                if (unlikely(is_wep && wl->default_key != idx)) {
-                        ret = wl1271_set_default_wep_key(wl, idx);
+                if (unlikely(is_wep && wlvif->default_key != idx)) {
+                        ret = wl1271_set_default_wep_key(wl, wlvif, idx);
                         if (ret < 0)
                                 return ret;
-                        wl->default_key = idx;
+                        wlvif->default_key = idx;
                 }
         }
-
-        hlid = wl1271_tx_get_hlid(wl, skb);
+        hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
         if (hlid == WL12XX_INVALID_LINK_ID) {
                 wl1271_error("invalid hlid. dropping skb 0x%p", skb);
                 return -EINVAL;
         }
 
-        ret = wl1271_tx_allocate(wl, skb, extra, buf_offset, hlid);
+        ret = wl1271_tx_allocate(wl, wlvif, skb, extra, buf_offset, hlid);
         if (ret < 0)
                 return ret;
 
-        wl1271_tx_fill_hdr(wl, skb, extra, info, hlid);
+        wl1271_tx_fill_hdr(wl, wlvif, skb, extra, info, hlid);
 
-        if (wl->bss_type == BSS_TYPE_AP_BSS) {
+        if (!is_dummy && wlvif && wlvif->bss_type == BSS_TYPE_AP_BSS) {
                 wl1271_tx_ap_update_inconnection_sta(wl, skb);
-                wl1271_tx_regulate_link(wl, hlid);
+                wl1271_tx_regulate_link(wl, wlvif, hlid);
         }
 
         /*
@@ -444,7 +456,7 @@ static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct sk_buff *skb,
         memset(wl->aggr_buf + buf_offset + skb->len, 0, total_len - skb->len);
 
         /* Revert side effects in the dummy packet skb, so it can be reused */
-        if (wl12xx_is_dummy_packet(wl, skb))
+        if (is_dummy)
                 skb_pull(skb, sizeof(struct wl1271_tx_hw_descr));
 
         return total_len;
@@ -522,19 +534,18 @@ static struct sk_buff_head *wl1271_select_queue(struct wl1271 *wl,
         return &queues[q];
 }
 
-static struct sk_buff *wl1271_sta_skb_dequeue(struct wl1271 *wl)
+static struct sk_buff *wl12xx_lnk_skb_dequeue(struct wl1271 *wl,
+                                              struct wl1271_link *lnk)
 {
-        struct sk_buff *skb = NULL;
+        struct sk_buff *skb;
         unsigned long flags;
         struct sk_buff_head *queue;
 
-        queue = wl1271_select_queue(wl, wl->tx_queue);
+        queue = wl1271_select_queue(wl, lnk->tx_queue);
         if (!queue)
-                goto out;
+                return NULL;
 
         skb = skb_dequeue(queue);
-
-out:
         if (skb) {
                 int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
                 spin_lock_irqsave(&wl->wl_lock, flags);
@@ -545,43 +556,33 @@ out:
         return skb;
 }
 
-static struct sk_buff *wl1271_ap_skb_dequeue(struct wl1271 *wl)
+static struct sk_buff *wl12xx_vif_skb_dequeue(struct wl1271 *wl,
+                                              struct wl12xx_vif *wlvif)
 {
         struct sk_buff *skb = NULL;
-        unsigned long flags;
         int i, h, start_hlid;
-        struct sk_buff_head *queue;
 
         /* start from the link after the last one */
-        start_hlid = (wl->last_tx_hlid + 1) % AP_MAX_LINKS;
+        start_hlid = (wlvif->last_tx_hlid + 1) % WL12XX_MAX_LINKS;
 
         /* dequeue according to AC, round robin on each link */
-        for (i = 0; i < AP_MAX_LINKS; i++) {
-                h = (start_hlid + i) % AP_MAX_LINKS;
+        for (i = 0; i < WL12XX_MAX_LINKS; i++) {
+                h = (start_hlid + i) % WL12XX_MAX_LINKS;
 
                 /* only consider connected stations */
-                if (h >= WL1271_AP_STA_HLID_START &&
-                    !test_bit(h - WL1271_AP_STA_HLID_START, wl->ap_hlid_map))
+                if (!test_bit(h, wlvif->links_map))
                         continue;
 
-                queue = wl1271_select_queue(wl, wl->links[h].tx_queue);
-                if (!queue)
+                skb = wl12xx_lnk_skb_dequeue(wl, &wl->links[h]);
+                if (!skb)
                         continue;
 
-                skb = skb_dequeue(queue);
-                if (skb)
-                        break;
+                wlvif->last_tx_hlid = h;
+                break;
         }
 
-        if (skb) {
-                int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
-                wl->last_tx_hlid = h;
-                spin_lock_irqsave(&wl->wl_lock, flags);
-                wl->tx_queue_count[q]--;
-                spin_unlock_irqrestore(&wl->wl_lock, flags);
-        } else {
-                wl->last_tx_hlid = 0;
-        }
+        if (!skb)
+                wlvif->last_tx_hlid = 0;
 
         return skb;
 }
@@ -589,12 +590,32 @@ static struct sk_buff *wl1271_ap_skb_dequeue(struct wl1271 *wl)
 static struct sk_buff *wl1271_skb_dequeue(struct wl1271 *wl)
 {
         unsigned long flags;
+        struct wl12xx_vif *wlvif = wl->last_wlvif;
         struct sk_buff *skb = NULL;
 
-        if (wl->bss_type == BSS_TYPE_AP_BSS)
-                skb = wl1271_ap_skb_dequeue(wl);
-        else
-                skb = wl1271_sta_skb_dequeue(wl);
+        if (wlvif) {
+                wl12xx_for_each_wlvif_continue(wl, wlvif) {
+                        skb = wl12xx_vif_skb_dequeue(wl, wlvif);
+                        if (skb) {
+                                wl->last_wlvif = wlvif;
+                                break;
+                        }
+                }
+        }
+
+        /* do another pass */
+        if (!skb) {
+                wl12xx_for_each_wlvif(wl, wlvif) {
+                        skb = wl12xx_vif_skb_dequeue(wl, wlvif);
+                        if (skb) {
+                                wl->last_wlvif = wlvif;
+                                break;
+                        }
+                }
+        }
+
+        if (!skb)
+                skb = wl12xx_lnk_skb_dequeue(wl, &wl->links[wl->system_hlid]);
 
         if (!skb &&
             test_and_clear_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags)) {
@@ -610,21 +631,21 @@ static struct sk_buff *wl1271_skb_dequeue(struct wl1271 *wl)
         return skb;
 }
 
-static void wl1271_skb_queue_head(struct wl1271 *wl, struct sk_buff *skb)
+static void wl1271_skb_queue_head(struct wl1271 *wl, struct wl12xx_vif *wlvif,
+                                  struct sk_buff *skb)
 {
         unsigned long flags;
         int q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
 
         if (wl12xx_is_dummy_packet(wl, skb)) {
                 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
-        } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
-                u8 hlid = wl1271_tx_get_hlid(wl, skb);
+        } else {
+                u8 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
                 skb_queue_head(&wl->links[hlid].tx_queue[q], skb);
 
                 /* make sure we dequeue the same packet next time */
-                wl->last_tx_hlid = (hlid + AP_MAX_LINKS - 1) % AP_MAX_LINKS;
-        } else {
-                skb_queue_head(&wl->tx_queue[q], skb);
+                wlvif->last_tx_hlid = (hlid + WL12XX_MAX_LINKS - 1) %
+                                      WL12XX_MAX_LINKS;
         }
 
         spin_lock_irqsave(&wl->wl_lock, flags);
@@ -639,29 +660,71 @@ static bool wl1271_tx_is_data_present(struct sk_buff *skb)
         return ieee80211_is_data_present(hdr->frame_control);
 }
 
+void wl12xx_rearm_rx_streaming(struct wl1271 *wl, unsigned long *active_hlids)
+{
+        struct wl12xx_vif *wlvif;
+        u32 timeout;
+        u8 hlid;
+
+        if (!wl->conf.rx_streaming.interval)
+                return;
+
+        if (!wl->conf.rx_streaming.always &&
+            !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags))
+                return;
+
+        timeout = wl->conf.rx_streaming.duration;
+        wl12xx_for_each_wlvif_sta(wl, wlvif) {
+                bool found = false;
+                for_each_set_bit(hlid, active_hlids, WL12XX_MAX_LINKS) {
+                        if (test_bit(hlid, wlvif->links_map)) {
+                                found  = true;
+                                break;
+                        }
+                }
+
+                if (!found)
+                        continue;
+
+                /* enable rx streaming */
+                if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
+                        ieee80211_queue_work(wl->hw,
+                                             &wlvif->rx_streaming_enable_work);
+
+                mod_timer(&wlvif->rx_streaming_timer,
+                          jiffies + msecs_to_jiffies(timeout));
+        }
+}
+
 void wl1271_tx_work_locked(struct wl1271 *wl)
 {
+        struct wl12xx_vif *wlvif;
         struct sk_buff *skb;
+        struct wl1271_tx_hw_descr *desc;
         u32 buf_offset = 0;
         bool sent_packets = false;
-        bool had_data = false;
-        bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
+        unsigned long active_hlids[BITS_TO_LONGS(WL12XX_MAX_LINKS)] = {0};
         int ret;
 
         if (unlikely(wl->state == WL1271_STATE_OFF))
                 return;
 
         while ((skb = wl1271_skb_dequeue(wl))) {
-                if (wl1271_tx_is_data_present(skb))
-                        had_data = true;
+                struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+                bool has_data = false;
 
-                ret = wl1271_prepare_tx_frame(wl, skb, buf_offset);
+                wlvif = NULL;
+                if (!wl12xx_is_dummy_packet(wl, skb) && info->control.vif)
+                        wlvif = wl12xx_vif_to_data(info->control.vif);
+
+                has_data = wlvif && wl1271_tx_is_data_present(skb);
+                ret = wl1271_prepare_tx_frame(wl, wlvif, skb, buf_offset);
                 if (ret == -EAGAIN) {
                         /*
                          * Aggregation buffer is full.
                          * Flush buffer and try again.
                          */
-                        wl1271_skb_queue_head(wl, skb);
+                        wl1271_skb_queue_head(wl, wlvif, skb);
                         wl1271_write(wl, WL1271_SLV_MEM_DATA, wl->aggr_buf,
                                      buf_offset, true);
                         sent_packets = true;
@@ -672,16 +735,27 @@ void wl1271_tx_work_locked(struct wl1271 *wl)
                          * Firmware buffer is full.
                          * Queue back last skb, and stop aggregating.
                          */
-                        wl1271_skb_queue_head(wl, skb);
+                        wl1271_skb_queue_head(wl, wlvif, skb);
                         /* No work left, avoid scheduling redundant tx work */
                         set_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
                         goto out_ack;
                 } else if (ret < 0) {
-                        dev_kfree_skb(skb);
+                        if (wl12xx_is_dummy_packet(wl, skb))
+                                /*
+                                 * fw still expects dummy packet,
+                                 * so re-enqueue it
+                                 */
+                                wl1271_skb_queue_head(wl, wlvif, skb);
+                        else
+                                ieee80211_free_txskb(wl->hw, skb);
                         goto out_ack;
                 }
                 buf_offset += ret;
                 wl->tx_packets_count++;
+                if (has_data) {
+                        desc = (struct wl1271_tx_hw_descr *) skb->data;
+                        __set_bit(desc->hlid, active_hlids);
+                }
         }
 
 out_ack:
@@ -701,19 +775,7 @@ out_ack:
 
                 wl1271_handle_tx_low_watermark(wl);
         }
-        if (!is_ap && wl->conf.rx_streaming.interval && had_data &&
-            (wl->conf.rx_streaming.always ||
-             test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags))) {
-                u32 timeout = wl->conf.rx_streaming.duration;
-
-                /* enable rx streaming */
-                if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
-                        ieee80211_queue_work(wl->hw,
-                                             &wl->rx_streaming_enable_work);
-
-                mod_timer(&wl->rx_streaming_timer,
-                          jiffies + msecs_to_jiffies(timeout));
-        }
+        wl12xx_rearm_rx_streaming(wl, active_hlids);
 }
 
 void wl1271_tx_work(struct work_struct *work)
@@ -737,6 +799,8 @@ static void wl1271_tx_complete_packet(struct wl1271 *wl,
                                       struct wl1271_tx_hw_res_descr *result)
 {
         struct ieee80211_tx_info *info;
+        struct ieee80211_vif *vif;
+        struct wl12xx_vif *wlvif;
         struct sk_buff *skb;
         int id = result->id;
         int rate = -1;
@@ -756,11 +820,16 @@ static void wl1271_tx_complete_packet(struct wl1271 *wl,
                 return;
         }
 
+        /* info->control is valid as long as we don't update info->status */
+        vif = info->control.vif;
+        wlvif = wl12xx_vif_to_data(vif);
+
         /* update the TX status info */
         if (result->status == TX_SUCCESS) {
                 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
                         info->flags |= IEEE80211_TX_STAT_ACK;
-                rate = wl1271_rate_to_idx(result->rate_class_index, wl->band);
+                rate = wl1271_rate_to_idx(result->rate_class_index,
+                                          wlvif->band);
                 retries = result->ack_failures;
         } else if (result->status == TX_RETRY_EXCEEDED) {
                 wl->stats.excessive_retries++;
@@ -783,14 +852,14 @@ static void wl1271_tx_complete_packet(struct wl1271 *wl,
              info->control.hw_key->cipher == WLAN_CIPHER_SUITE_CCMP ||
              info->control.hw_key->cipher == WL1271_CIPHER_SUITE_GEM)) {
                 u8 fw_lsb = result->tx_security_sequence_number_lsb;
-                u8 cur_lsb = wl->tx_security_last_seq_lsb;
+                u8 cur_lsb = wlvif->tx_security_last_seq_lsb;
 
                 /*
                  * update security sequence number, taking care of potential
                  * wrap-around
                  */
-                wl->tx_security_seq += (fw_lsb - cur_lsb + 256) % 256;
-                wl->tx_security_last_seq_lsb = fw_lsb;
+                wlvif->tx_security_seq += (fw_lsb - cur_lsb) & 0xff;
+                wlvif->tx_security_last_seq_lsb = fw_lsb;
         }
 
         /* remove private header from packet */
@@ -886,39 +955,30 @@ void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid)
 }
 
 /* caller must hold wl->mutex and TX must be stopped */
-void wl1271_tx_reset(struct wl1271 *wl, bool reset_tx_queues)
+void wl12xx_tx_reset_wlvif(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 {
         int i;
-        struct sk_buff *skb;
-        struct ieee80211_tx_info *info;
 
         /* TX failure */
-        if (wl->bss_type == BSS_TYPE_AP_BSS) {
-                for (i = 0; i < AP_MAX_LINKS; i++) {
-                        wl1271_free_sta(wl, i);
-                        wl1271_tx_reset_link_queues(wl, i);
-                        wl->links[i].allocated_pkts = 0;
-                        wl->links[i].prev_freed_pkts = 0;
-                }
-
-                wl->last_tx_hlid = 0;
-        } else {
-                for (i = 0; i < NUM_TX_QUEUES; i++) {
-                        while ((skb = skb_dequeue(&wl->tx_queue[i]))) {
-                                wl1271_debug(DEBUG_TX, "freeing skb 0x%p",
-                                             skb);
-
-                                if (!wl12xx_is_dummy_packet(wl, skb)) {
-                                        info = IEEE80211_SKB_CB(skb);
-                                        info->status.rates[0].idx = -1;
-                                        info->status.rates[0].count = 0;
-                                        ieee80211_tx_status_ni(wl->hw, skb);
-                                }
-                        }
-                }
+        for_each_set_bit(i, wlvif->links_map, WL12XX_MAX_LINKS) {
+                if (wlvif->bss_type == BSS_TYPE_AP_BSS)
+                        wl1271_free_sta(wl, wlvif, i);
+                else
+                        wlvif->sta.ba_rx_bitmap = 0;
 
-                wl->ba_rx_bitmap = 0;
+                wl1271_tx_reset_link_queues(wl, i);
+                wl->links[i].allocated_pkts = 0;
+                wl->links[i].prev_freed_pkts = 0;
         }
+        wlvif->last_tx_hlid = 0;
+
+}
+/* caller must hold wl->mutex and TX must be stopped */
+void wl12xx_tx_reset(struct wl1271 *wl, bool reset_tx_queues)
+{
+        int i;
+        struct sk_buff *skb;
+        struct ieee80211_tx_info *info;
 
         for (i = 0; i < NUM_TX_QUEUES; i++)
                 wl->tx_queue_count[i] = 0;