1 files changed, 123 insertions, 105 deletions

diff --git a/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c b/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c
index 29b1f24c2d0f..82f9140f3d35 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c
@@ -422,9 +422,12 @@ struct brcmf_fws_macdesc_table {
 
 struct brcmf_fws_info {
         struct brcmf_pub *drvr;
+        spinlock_t spinlock;
+        ulong flags;
         struct brcmf_fws_stats stats;
         struct brcmf_fws_hanger hanger;
         enum brcmf_fws_fcmode fcmode;
+        bool fw_signals;
         bool bcmc_credit_check;
         struct brcmf_fws_macdesc_table desc;
         struct workqueue_struct *fws_wq;
@@ -483,6 +486,18 @@ static int brcmf_fws_get_tlv_len(struct brcmf_fws_info *fws,
 }
 #undef BRCMF_FWS_TLV_DEF
 
+static void brcmf_fws_lock(struct brcmf_fws_info *fws)
+                __acquires(&fws->spinlock)
+{
+        spin_lock_irqsave(&fws->spinlock, fws->flags);
+}
+
+static void brcmf_fws_unlock(struct brcmf_fws_info *fws)
+                __releases(&fws->spinlock)
+{
+        spin_unlock_irqrestore(&fws->spinlock, fws->flags);
+}
+
 static bool brcmf_fws_ifidx_match(struct sk_buff *skb, void *arg)
 {
         u32 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX);
@@ -869,8 +884,11 @@ static bool brcmf_fws_tim_update(struct brcmf_fws_info *fws,
                 skcb->state = BRCMF_FWS_SKBSTATE_TIM;
                 bus = fws->drvr->bus_if;
                 err = brcmf_fws_hdrpush(fws, skb);
-                if (err == 0)
+                if (err == 0) {
+                        brcmf_fws_unlock(fws);
                         err = brcmf_bus_txdata(bus, skb);
+                        brcmf_fws_lock(fws);
+                }
                 if (err)
                         brcmu_pkt_buf_free_skb(skb);
                 return true;
@@ -905,26 +923,10 @@ static int brcmf_fws_rssi_indicate(struct brcmf_fws_info *fws, s8 rssi)
         return 0;
 }
 
-/* using macro so sparse checking does not complain
- * about locking imbalance.
- */
-#define brcmf_fws_lock(drvr, flags)                             \
-do {                                                            \
-        flags = 0;                                              \
-        spin_lock_irqsave(&((drvr)->fws_spinlock), (flags));    \
-} while (0)
-
-/* using macro so sparse checking does not complain
- * about locking imbalance.
- */
-#define brcmf_fws_unlock(drvr, flags) \
-        spin_unlock_irqrestore(&((drvr)->fws_spinlock), (flags))
-
 static
 int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data)
 {
         struct brcmf_fws_mac_descriptor *entry, *existing;
-        ulong flags;
         u8 mac_handle;
         u8 ifidx;
         u8 *addr;
@@ -938,10 +940,10 @@ int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data)
                 if (entry->occupied) {
                         brcmf_dbg(TRACE, "deleting %s mac %pM\n",
                                   entry->name, addr);
-                        brcmf_fws_lock(fws->drvr, flags);
+                        brcmf_fws_lock(fws);
                         brcmf_fws_macdesc_cleanup(fws, entry, -1);
                         brcmf_fws_macdesc_deinit(entry);
-                        brcmf_fws_unlock(fws->drvr, flags);
+                        brcmf_fws_unlock(fws);
                 } else
                         fws->stats.mac_update_failed++;
                 return 0;
@@ -950,13 +952,13 @@ int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data)
         existing = brcmf_fws_macdesc_lookup(fws, addr);
         if (IS_ERR(existing)) {
                 if (!entry->occupied) {
-                        brcmf_fws_lock(fws->drvr, flags);
+                        brcmf_fws_lock(fws);
                         entry->mac_handle = mac_handle;
                         brcmf_fws_macdesc_init(entry, addr, ifidx);
                         brcmf_fws_macdesc_set_name(fws, entry);
                         brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT,
                                         BRCMF_FWS_PSQ_LEN);
-                        brcmf_fws_unlock(fws->drvr, flags);
+                        brcmf_fws_unlock(fws);
                         brcmf_dbg(TRACE, "add %s mac %pM\n", entry->name, addr);
                 } else {
                         fws->stats.mac_update_failed++;
@@ -964,13 +966,13 @@ int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data)
         } else {
                 if (entry != existing) {
                         brcmf_dbg(TRACE, "copy mac %s\n", existing->name);
-                        brcmf_fws_lock(fws->drvr, flags);
+                        brcmf_fws_lock(fws);
                         memcpy(entry, existing,
                                offsetof(struct brcmf_fws_mac_descriptor, psq));
                         entry->mac_handle = mac_handle;
                         brcmf_fws_macdesc_deinit(existing);
                         brcmf_fws_macdesc_set_name(fws, entry);
-                        brcmf_fws_unlock(fws->drvr, flags);
+                        brcmf_fws_unlock(fws);
                         brcmf_dbg(TRACE, "relocate %s mac %pM\n", entry->name,
                                   addr);
                 } else {
@@ -986,7 +988,6 @@ static int brcmf_fws_macdesc_state_indicate(struct brcmf_fws_info *fws,
                                             u8 type, u8 *data)
 {
         struct brcmf_fws_mac_descriptor *entry;
-        ulong flags;
         u8 mac_handle;
         int ret;
 
@@ -996,7 +997,7 @@ static int brcmf_fws_macdesc_state_indicate(struct brcmf_fws_info *fws,
                 fws->stats.mac_ps_update_failed++;
                 return -ESRCH;
         }
-        brcmf_fws_lock(fws->drvr, flags);
+        brcmf_fws_lock(fws);
         /* a state update should wipe old credits */
         entry->requested_credit = 0;
         entry->requested_packet = 0;
@@ -1011,7 +1012,7 @@ static int brcmf_fws_macdesc_state_indicate(struct brcmf_fws_info *fws,
                 brcmf_fws_tim_update(fws, entry, BRCMF_FWS_FIFO_AC_VO, true);
                 ret = BRCMF_FWS_RET_OK_NOSCHEDULE;
         }
-        brcmf_fws_unlock(fws->drvr, flags);
+        brcmf_fws_unlock(fws);
         return ret;
 }
 
@@ -1019,7 +1020,6 @@ static int brcmf_fws_interface_state_indicate(struct brcmf_fws_info *fws,
                                               u8 type, u8 *data)
 {
         struct brcmf_fws_mac_descriptor *entry;
-        ulong flags;
         u8 ifidx;
         int ret;
 
@@ -1038,7 +1038,7 @@ static int brcmf_fws_interface_state_indicate(struct brcmf_fws_info *fws,
 
         brcmf_dbg(TRACE, "%s (%d): %s\n", brcmf_fws_get_tlv_name(type), type,
                   entry->name);
-        brcmf_fws_lock(fws->drvr, flags);
+        brcmf_fws_lock(fws);
         switch (type) {
         case BRCMF_FWS_TYPE_INTERFACE_OPEN:
                 entry->state = BRCMF_FWS_STATE_OPEN;
@@ -1050,10 +1050,10 @@ static int brcmf_fws_interface_state_indicate(struct brcmf_fws_info *fws,
                 break;
         default:
                 ret = -EINVAL;
-                brcmf_fws_unlock(fws->drvr, flags);
+                brcmf_fws_unlock(fws);
                 goto fail;
         }
-        brcmf_fws_unlock(fws->drvr, flags);
+        brcmf_fws_unlock(fws);
         return ret;
 
 fail:
@@ -1065,7 +1065,6 @@ static int brcmf_fws_request_indicate(struct brcmf_fws_info *fws, u8 type,
                                       u8 *data)
 {
         struct brcmf_fws_mac_descriptor *entry;
-        ulong flags;
 
         entry = &fws->desc.nodes[data[1] & 0x1F];
         if (!entry->occupied) {
@@ -1079,14 +1078,14 @@ static int brcmf_fws_request_indicate(struct brcmf_fws_info *fws, u8 type,
         brcmf_dbg(TRACE, "%s (%d): %s cnt %d bmp %d\n",
                   brcmf_fws_get_tlv_name(type), type, entry->name,
                   data[0], data[2]);
-        brcmf_fws_lock(fws->drvr, flags);
+        brcmf_fws_lock(fws);
         if (type == BRCMF_FWS_TYPE_MAC_REQUEST_CREDIT)
                 entry->requested_credit = data[0];
         else
                 entry->requested_packet = data[0];
 
         entry->ac_bitmap = data[2];
-        brcmf_fws_unlock(fws->drvr, flags);
+        brcmf_fws_unlock(fws);
         return BRCMF_FWS_RET_OK_SCHEDULE;
 }
 
@@ -1160,7 +1159,8 @@ static void brcmf_fws_return_credits(struct brcmf_fws_info *fws,
 static void brcmf_fws_schedule_deq(struct brcmf_fws_info *fws)
 {
         /* only schedule dequeue when there are credits for delayed traffic */
-        if (fws->fifo_credit_map & fws->fifo_delay_map)
+        if ((fws->fifo_credit_map & fws->fifo_delay_map) ||
+            (!brcmf_fws_fc_active(fws) && fws->fifo_delay_map))
                 queue_work(fws->fws_wq, &fws->fws_dequeue_work);
 }
 
@@ -1383,7 +1383,6 @@ brcmf_fws_txs_process(struct brcmf_fws_info *fws, u8 flags, u32 hslot,
 static int brcmf_fws_fifocreditback_indicate(struct brcmf_fws_info *fws,
                                              u8 *data)
 {
-        ulong flags;
         int i;
 
         if (fws->fcmode != BRCMF_FWS_FCMODE_EXPLICIT_CREDIT) {
@@ -1392,19 +1391,18 @@ static int brcmf_fws_fifocreditback_indicate(struct brcmf_fws_info *fws,
         }
 
         brcmf_dbg(DATA, "enter: data %pM\n", data);
-        brcmf_fws_lock(fws->drvr, flags);
+        brcmf_fws_lock(fws);
         for (i = 0; i < BRCMF_FWS_FIFO_COUNT; i++)
                 brcmf_fws_return_credits(fws, i, data[i]);
 
         brcmf_dbg(DATA, "map: credit %x delay %x\n", fws->fifo_credit_map,
                   fws->fifo_delay_map);
-        brcmf_fws_unlock(fws->drvr, flags);
+        brcmf_fws_unlock(fws);
         return BRCMF_FWS_RET_OK_SCHEDULE;
 }
 
 static int brcmf_fws_txstatus_indicate(struct brcmf_fws_info *fws, u8 *data)
 {
-        ulong lflags;
         __le32 status_le;
         u32 status;
         u32 hslot;
@@ -1418,9 +1416,9 @@ static int brcmf_fws_txstatus_indicate(struct brcmf_fws_info *fws, u8 *data)
         hslot = brcmf_txstatus_get_field(status, HSLOT);
         genbit = brcmf_txstatus_get_field(status, GENERATION);
 
-        brcmf_fws_lock(fws->drvr, lflags);
+        brcmf_fws_lock(fws);
         brcmf_fws_txs_process(fws, flags, hslot, genbit);
-        brcmf_fws_unlock(fws->drvr, lflags);
+        brcmf_fws_unlock(fws);
         return BRCMF_FWS_RET_OK_NOSCHEDULE;
 }
 
@@ -1440,7 +1438,6 @@ static int brcmf_fws_notify_credit_map(struct brcmf_if *ifp,
 {
         struct brcmf_fws_info *fws = ifp->drvr->fws;
         int i;
-        ulong flags;
         u8 *credits = data;
 
         if (e->datalen < BRCMF_FWS_FIFO_COUNT) {
@@ -1453,7 +1450,7 @@ static int brcmf_fws_notify_credit_map(struct brcmf_if *ifp,
         fws->creditmap_received = true;
 
         brcmf_dbg(TRACE, "enter: credits %pM\n", credits);
-        brcmf_fws_lock(ifp->drvr, flags);
+        brcmf_fws_lock(fws);
         for (i = 0; i < ARRAY_SIZE(fws->fifo_credit); i++) {
                 if (*credits)
                         fws->fifo_credit_map |= 1 << i;
@@ -1462,7 +1459,7 @@ static int brcmf_fws_notify_credit_map(struct brcmf_if *ifp,
                 fws->fifo_credit[i] = *credits++;
         }
         brcmf_fws_schedule_deq(fws);
-        brcmf_fws_unlock(ifp->drvr, flags);
+        brcmf_fws_unlock(fws);
         return 0;
 }
 
@@ -1471,18 +1468,18 @@ static int brcmf_fws_notify_bcmc_credit_support(struct brcmf_if *ifp,
                                                 void *data)
 {
         struct brcmf_fws_info *fws = ifp->drvr->fws;
-        ulong flags;
 
-        brcmf_fws_lock(ifp->drvr, flags);
+        brcmf_fws_lock(fws);
         if (fws)
                 fws->bcmc_credit_check = true;
-        brcmf_fws_unlock(ifp->drvr, flags);
+        brcmf_fws_unlock(fws);
         return 0;
 }
 
 int brcmf_fws_hdrpull(struct brcmf_pub *drvr, int ifidx, s16 signal_len,
                       struct sk_buff *skb)
 {
+        struct brcmf_skb_reorder_data *rd;
         struct brcmf_fws_info *fws = drvr->fws;
         u8 *signal_data;
         s16 data_len;
@@ -1497,8 +1494,10 @@ int brcmf_fws_hdrpull(struct brcmf_pub *drvr, int ifidx, s16 signal_len,
 
         WARN_ON(signal_len > skb->len);
 
+        if (!signal_len)
+                return 0;
         /* if flow control disabled, skip to packet data and leave */
-        if (!signal_len || !drvr->fw_signals) {
+        if (!fws->fw_signals) {
                 skb_pull(skb, signal_len);
                 return 0;
         }
@@ -1536,9 +1535,12 @@ int brcmf_fws_hdrpull(struct brcmf_pub *drvr, int ifidx, s16 signal_len,
 
                 err = BRCMF_FWS_RET_OK_NOSCHEDULE;
                 switch (type) {
-                case BRCMF_FWS_TYPE_HOST_REORDER_RXPKTS:
                 case BRCMF_FWS_TYPE_COMP_TXSTATUS:
                         break;
+                case BRCMF_FWS_TYPE_HOST_REORDER_RXPKTS:
+                        rd = (struct brcmf_skb_reorder_data *)skb->cb;
+                        rd->reorder = data;
+                        break;
                 case BRCMF_FWS_TYPE_MACDESC_ADD:
                 case BRCMF_FWS_TYPE_MACDESC_DEL:
                         brcmf_fws_macdesc_indicate(fws, type, data);
@@ -1694,17 +1696,22 @@ static int brcmf_fws_commit_skb(struct brcmf_fws_info *fws, int fifo,
                 return PTR_ERR(entry);
 
         brcmf_fws_precommit_skb(fws, fifo, skb);
+        entry->transit_count++;
+        if (entry->suppressed)
+                entry->suppr_transit_count++;
+        brcmf_fws_unlock(fws);
         rc = brcmf_bus_txdata(bus, skb);
+        brcmf_fws_lock(fws);
         brcmf_dbg(DATA, "%s flags %X htod %X bus_tx %d\n", entry->name,
                   skcb->if_flags, skcb->htod, rc);
         if (rc < 0) {
+                entry->transit_count--;
+                if (entry->suppressed)
+                        entry->suppr_transit_count--;
                 brcmf_proto_hdrpull(fws->drvr, false, &ifidx, skb);
                 goto rollback;
         }
 
-        entry->transit_count++;
-        if (entry->suppressed)
-                entry->suppr_transit_count++;
         fws->stats.pkt2bus++;
         fws->stats.send_pkts[fifo]++;
         if (brcmf_skb_if_flags_get_field(skb, REQUESTED))
@@ -1741,11 +1748,11 @@ int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb)
         struct brcmf_fws_info *fws = drvr->fws;
         struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb);
         struct ethhdr *eh = (struct ethhdr *)(skb->data);
-        ulong flags;
         int fifo = BRCMF_FWS_FIFO_BCMC;
         bool multicast = is_multicast_ether_addr(eh->h_dest);
         bool pae = eh->h_proto == htons(ETH_P_PAE);
 
+        brcmf_dbg(DATA, "tx proto=0x%X\n", ntohs(eh->h_proto));
         /* determine the priority */
         if (!skb->priority)
                 skb->priority = cfg80211_classify8021d(skb);
@@ -1754,14 +1761,6 @@ int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb)
         if (pae)
                 atomic_inc(&ifp->pend_8021x_cnt);
 
-        if (!brcmf_fws_fc_active(fws)) {
-                /* If the protocol uses a data header, apply it */
-                brcmf_proto_hdrpush(drvr, ifp->ifidx, 0, skb);
-
-                /* Use bus module to send data frame */
-                return brcmf_bus_txdata(drvr->bus_if, skb);
-        }
-
         /* set control buffer information */
         skcb->if_flags = 0;
         skcb->state = BRCMF_FWS_SKBSTATE_NEW;
@@ -1769,7 +1768,7 @@ int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb)
         if (!multicast)
                 fifo = brcmf_fws_prio2fifo[skb->priority];
 
-        brcmf_fws_lock(drvr, flags);
+        brcmf_fws_lock(fws);
         if (fifo != BRCMF_FWS_FIFO_AC_BE && fifo < BRCMF_FWS_FIFO_BCMC)
                 fws->borrow_defer_timestamp = jiffies +
                                               BRCMF_FWS_BORROW_DEFER_PERIOD;
@@ -1789,7 +1788,7 @@ int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb)
                 }
                 brcmu_pkt_buf_free_skb(skb);
         }
-        brcmf_fws_unlock(drvr, flags);
+        brcmf_fws_unlock(fws);
         return 0;
 }
 
@@ -1809,7 +1808,7 @@ void brcmf_fws_add_interface(struct brcmf_if *ifp)
         struct brcmf_fws_info *fws = ifp->drvr->fws;
         struct brcmf_fws_mac_descriptor *entry;
 
-        if (!ifp->ndev || !ifp->drvr->fw_signals)
+        if (!ifp->ndev)
                 return;
 
         entry = &fws->desc.iface[ifp->ifidx];
@@ -1824,31 +1823,54 @@ void brcmf_fws_add_interface(struct brcmf_if *ifp)
 void brcmf_fws_del_interface(struct brcmf_if *ifp)
 {
         struct brcmf_fws_mac_descriptor *entry = ifp->fws_desc;
-        ulong flags;
 
         if (!entry)
                 return;
 
-        brcmf_fws_lock(ifp->drvr, flags);
+        brcmf_fws_lock(ifp->drvr->fws);
         ifp->fws_desc = NULL;
         brcmf_dbg(TRACE, "deleting %s\n", entry->name);
         brcmf_fws_macdesc_deinit(entry);
         brcmf_fws_cleanup(ifp->drvr->fws, ifp->ifidx);
-        brcmf_fws_unlock(ifp->drvr, flags);
+        brcmf_fws_unlock(ifp->drvr->fws);
 }
 
 static void brcmf_fws_dequeue_worker(struct work_struct *worker)
 {
         struct brcmf_fws_info *fws;
+        struct brcmf_pub *drvr;
         struct sk_buff *skb;
-        ulong flags;
         int fifo;
+        u32 hslot;
+        u32 ifidx;
+        int ret;
 
         fws = container_of(worker, struct brcmf_fws_info, fws_dequeue_work);
+        drvr = fws->drvr;
 
-        brcmf_fws_lock(fws->drvr, flags);
+        brcmf_fws_lock(fws);
         for (fifo = BRCMF_FWS_FIFO_BCMC; fifo >= 0 && !fws->bus_flow_blocked;
              fifo--) {
+                if (!brcmf_fws_fc_active(fws)) {
+                        while ((skb = brcmf_fws_deq(fws, fifo)) != NULL) {
+                                hslot = brcmf_skb_htod_tag_get_field(skb,
+                                                                     HSLOT);
+                                brcmf_fws_hanger_poppkt(&fws->hanger, hslot,
+                                                        &skb, true);
+                                ifidx = brcmf_skb_if_flags_get_field(skb,
+                                                                     INDEX);
+                                brcmf_proto_hdrpush(drvr, ifidx, 0, skb);
+                                /* Use bus module to send data frame */
+                                brcmf_fws_unlock(fws);
+                                ret = brcmf_bus_txdata(drvr->bus_if, skb);
+                                brcmf_fws_lock(fws);
+                                if (ret < 0)
+                                        brcmf_txfinalize(drvr, skb, false);
+                                if (fws->bus_flow_blocked)
+                                        break;
+                        }
+                        continue;
+                }
                 while ((fws->fifo_credit[fifo]) || ((!fws->bcmc_credit_check) &&
                        (fifo == BRCMF_FWS_FIFO_BCMC))) {
                         skb = brcmf_fws_deq(fws, fifo);
@@ -1876,42 +1898,43 @@ static void brcmf_fws_dequeue_worker(struct work_struct *worker)
                         }
                 }
         }
-        brcmf_fws_unlock(fws->drvr, flags);
+        brcmf_fws_unlock(fws);
 }
 
 int brcmf_fws_init(struct brcmf_pub *drvr)
 {
+        struct brcmf_fws_info *fws;
         u32 tlv = BRCMF_FWS_FLAGS_RSSI_SIGNALS;
         int rc;
 
-        if (!drvr->fw_signals)
-                return 0;
-
-        spin_lock_init(&drvr->fws_spinlock);
-
         drvr->fws = kzalloc(sizeof(*(drvr->fws)), GFP_KERNEL);
         if (!drvr->fws) {
                 rc = -ENOMEM;
                 goto fail;
         }
 
+        fws = drvr->fws;
+
+        spin_lock_init(&fws->spinlock);
+
         /* set linkage back */
-        drvr->fws->drvr = drvr;
-        drvr->fws->fcmode = fcmode;
+        fws->drvr = drvr;
+        fws->fcmode = fcmode;
 
-        drvr->fws->fws_wq = create_singlethread_workqueue("brcmf_fws_wq");
-        if (drvr->fws->fws_wq == NULL) {
+        fws->fws_wq = create_singlethread_workqueue("brcmf_fws_wq");
+        if (fws->fws_wq == NULL) {
                 brcmf_err("workqueue creation failed\n");
                 rc = -EBADF;
                 goto fail;
         }
-        INIT_WORK(&drvr->fws->fws_dequeue_work, brcmf_fws_dequeue_worker);
+        INIT_WORK(&fws->fws_dequeue_work, brcmf_fws_dequeue_worker);
 
         /* enable firmware signalling if fcmode active */
-        if (drvr->fws->fcmode != BRCMF_FWS_FCMODE_NONE)
+        if (fws->fcmode != BRCMF_FWS_FCMODE_NONE)
                 tlv |= BRCMF_FWS_FLAGS_XONXOFF_SIGNALS |
                        BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS |
-                       BRCMF_FWS_FLAGS_HOST_PROPTXSTATUS_ACTIVE;
+                       BRCMF_FWS_FLAGS_HOST_PROPTXSTATUS_ACTIVE |
+                       BRCMF_FWS_FLAGS_HOST_RXREORDER_ACTIVE;
 
         rc = brcmf_fweh_register(drvr, BRCMF_E_FIFO_CREDIT_MAP,
                                  brcmf_fws_notify_credit_map);
@@ -1927,31 +1950,33 @@ int brcmf_fws_init(struct brcmf_pub *drvr)
                 goto fail;
         }
 
-        /* setting the iovar may fail if feature is unsupported
+        /* Setting the iovar may fail if feature is unsupported
          * so leave the rc as is so driver initialization can
-         * continue.
+         * continue. Set mode back to none indicating not enabled.
          */
+        fws->fw_signals = true;
         if (brcmf_fil_iovar_int_set(drvr->iflist[0], "tlv", tlv)) {
                 brcmf_err("failed to set bdcv2 tlv signaling\n");
-                goto fail_event;
+                fws->fcmode = BRCMF_FWS_FCMODE_NONE;
+                fws->fw_signals = false;
         }
 
-        brcmf_fws_hanger_init(&drvr->fws->hanger);
-        brcmf_fws_macdesc_init(&drvr->fws->desc.other, NULL, 0);
-        brcmf_fws_macdesc_set_name(drvr->fws, &drvr->fws->desc.other);
-        brcmu_pktq_init(&drvr->fws->desc.other.psq, BRCMF_FWS_PSQ_PREC_COUNT,
+        if (brcmf_fil_iovar_int_set(drvr->iflist[0], "ampdu_hostreorder", 1))
+                brcmf_dbg(INFO, "enabling AMPDU host-reorder failed\n");
+
+        brcmf_fws_hanger_init(&fws->hanger);
+        brcmf_fws_macdesc_init(&fws->desc.other, NULL, 0);
+        brcmf_fws_macdesc_set_name(fws, &fws->desc.other);
+        brcmu_pktq_init(&fws->desc.other.psq, BRCMF_FWS_PSQ_PREC_COUNT,
                         BRCMF_FWS_PSQ_LEN);
 
         /* create debugfs file for statistics */
-        brcmf_debugfs_create_fws_stats(drvr, &drvr->fws->stats);
+        brcmf_debugfs_create_fws_stats(drvr, &fws->stats);
 
         brcmf_dbg(INFO, "%s bdcv2 tlv signaling [%x]\n",
-                  drvr->fw_signals ? "enabled" : "disabled", tlv);
+                  fws->fw_signals ? "enabled" : "disabled", tlv);
         return 0;
 
-fail_event:
-        brcmf_fweh_unregister(drvr, BRCMF_E_BCMC_CREDIT_SUPPORT);
-        brcmf_fweh_unregister(drvr, BRCMF_E_FIFO_CREDIT_MAP);
 fail:
         brcmf_fws_deinit(drvr);
         return rc;
@@ -1960,24 +1985,18 @@ fail:
 void brcmf_fws_deinit(struct brcmf_pub *drvr)
 {
         struct brcmf_fws_info *fws = drvr->fws;
-        ulong flags;
 
         if (!fws)
                 return;
 
-        /* disable firmware signalling entirely
-         * to avoid using the workqueue.
-         */
-        drvr->fw_signals = false;
-
         if (drvr->fws->fws_wq)
                 destroy_workqueue(drvr->fws->fws_wq);
 
         /* cleanup */
-        brcmf_fws_lock(drvr, flags);
+        brcmf_fws_lock(fws);
         brcmf_fws_cleanup(fws, -1);
         drvr->fws = NULL;
-        brcmf_fws_unlock(drvr, flags);
+        brcmf_fws_unlock(fws);
 
         /* free top structure */
         kfree(fws);
@@ -1985,7 +2004,7 @@ void brcmf_fws_deinit(struct brcmf_pub *drvr)
 
 bool brcmf_fws_fc_active(struct brcmf_fws_info *fws)
 {
-        if (!fws)
+        if (!fws->creditmap_received)
                 return false;
 
         return fws->fcmode != BRCMF_FWS_FCMODE_NONE;
@@ -1993,17 +2012,16 @@ bool brcmf_fws_fc_active(struct brcmf_fws_info *fws)
 
 void brcmf_fws_bustxfail(struct brcmf_fws_info *fws, struct sk_buff *skb)
 {
-        ulong flags;
         u32 hslot;
 
         if (brcmf_skbcb(skb)->state == BRCMF_FWS_SKBSTATE_TIM) {
                 brcmu_pkt_buf_free_skb(skb);
                 return;
         }
-        brcmf_fws_lock(fws->drvr, flags);
+        brcmf_fws_lock(fws);
         hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT);
         brcmf_fws_txs_process(fws, BRCMF_FWS_TXSTATUS_HOST_TOSSED, hslot, 0);
-        brcmf_fws_unlock(fws->drvr, flags);
+        brcmf_fws_unlock(fws);
 }
 
 void brcmf_fws_bus_blocked(struct brcmf_pub *drvr, bool flow_blocked)