Merge tag 'wireless-drivers-next-for-davem-2015-03-06' of git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/wireless-drivers-next

Major changes:

brcmfmac:

* sdio improvements
* add a debugfs file so users can provide us all the revinfo we could
  ask for

iwlwifi:

* add triggers for firmware dump collection
* remove support for -9.ucode
* new statitics API
* rate control improvements

ath9k:

* add per-vif TX power capability
* BT coexistance fixes

ath10k:

* qca6174: enable STA transmit beamforming (TxBF) support
* disable multi-vif power save by default

bcma:

* enable support for PCIe Gen 2 host devices

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

5 files changed, 274 insertions, 97 deletions

diff --git a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
index 7944224e3fc9..c438ccdb6ed8 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
@@ -58,6 +58,14 @@
 #define BRCMF_DEFAULT_TXGLOM_SIZE       32  /* max tx frames in glom chain */
 #define BRCMF_DEFAULT_RXGLOM_SIZE       32  /* max rx frames in glom chain */
 
+struct brcmf_sdiod_freezer {
+        atomic_t freezing;
+        atomic_t thread_count;
+        u32 frozen_count;
+        wait_queue_head_t thread_freeze;
+        struct completion resumed;
+};
+
 static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;
 module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);
 MODULE_PARM_DESC(txglomsz, "maximum tx packet chain size [SDIO]");
@@ -197,6 +205,30 @@ int brcmf_sdiod_intr_unregister(struct brcmf_sdio_dev *sdiodev)
         return 0;
 }
 
+void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
+                              enum brcmf_sdiod_state state)
+{
+        if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM ||
+            state == sdiodev->state)
+                return;
+
+        brcmf_dbg(TRACE, "%d -> %d\n", sdiodev->state, state);
+        switch (sdiodev->state) {
+        case BRCMF_SDIOD_DATA:
+                /* any other state means bus interface is down */
+                brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_DOWN);
+                break;
+        case BRCMF_SDIOD_DOWN:
+                /* transition from DOWN to DATA means bus interface is up */
+                if (state == BRCMF_SDIOD_DATA)
+                        brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_UP);
+                break;
+        default:
+                break;
+        }
+        sdiodev->state = state;
+}
+
 static inline int brcmf_sdiod_f0_writeb(struct sdio_func *func,
                                         uint regaddr, u8 byte)
 {
@@ -269,12 +301,6 @@ static int brcmf_sdiod_request_data(struct brcmf_sdio_dev *sdiodev, u8 fn,
         return ret;
 }
 
-static void brcmf_sdiod_nomedium_state(struct brcmf_sdio_dev *sdiodev)
-{
-        sdiodev->state = BRCMF_STATE_NOMEDIUM;
-        brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_DOWN);
-}
-
 static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
                                    u8 regsz, void *data, bool write)
 {
@@ -282,7 +308,7 @@ static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
         s32 retry = 0;
         int ret;
 
-        if (sdiodev->state == BRCMF_STATE_NOMEDIUM)
+        if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
                 return -ENOMEDIUM;
 
         /*
@@ -308,7 +334,7 @@ static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
                  retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
 
         if (ret == -ENOMEDIUM)
-                brcmf_sdiod_nomedium_state(sdiodev);
+                brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
         else if (ret != 0) {
                 /*
                  * SleepCSR register access can fail when
@@ -331,7 +357,7 @@ brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
         int err = 0, i;
         u8 addr[3];
 
-        if (sdiodev->state == BRCMF_STATE_NOMEDIUM)
+        if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
                 return -ENOMEDIUM;
 
         addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
@@ -460,7 +486,7 @@ static int brcmf_sdiod_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn,
                 err = sdio_readsb(sdiodev->func[fn], ((u8 *)(pkt->data)), addr,
                                   req_sz);
         if (err == -ENOMEDIUM)
-                brcmf_sdiod_nomedium_state(sdiodev);
+                brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
         return err;
 }
 
@@ -595,7 +621,7 @@ static int brcmf_sdiod_sglist_rw(struct brcmf_sdio_dev *sdiodev, uint fn,
 
                 ret = mmc_cmd.error ? mmc_cmd.error : mmc_dat.error;
                 if (ret == -ENOMEDIUM) {
-                        brcmf_sdiod_nomedium_state(sdiodev);
+                        brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
                         break;
                 } else if (ret != 0) {
                         brcmf_err("CMD53 sg block %s failed %d\n",
@@ -877,6 +903,87 @@ static void brcmf_sdiod_sgtable_alloc(struct brcmf_sdio_dev *sdiodev)
         sdiodev->txglomsz = brcmf_sdiod_txglomsz;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
+{
+        sdiodev->freezer = kzalloc(sizeof(*sdiodev->freezer), GFP_KERNEL);
+        if (!sdiodev->freezer)
+                return -ENOMEM;
+        atomic_set(&sdiodev->freezer->thread_count, 0);
+        atomic_set(&sdiodev->freezer->freezing, 0);
+        init_waitqueue_head(&sdiodev->freezer->thread_freeze);
+        init_completion(&sdiodev->freezer->resumed);
+        return 0;
+}
+
+static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
+{
+        if (sdiodev->freezer) {
+                WARN_ON(atomic_read(&sdiodev->freezer->freezing));
+                kfree(sdiodev->freezer);
+        }
+}
+
+static int brcmf_sdiod_freezer_on(struct brcmf_sdio_dev *sdiodev)
+{
+        atomic_t *expect = &sdiodev->freezer->thread_count;
+        int res = 0;
+
+        sdiodev->freezer->frozen_count = 0;
+        reinit_completion(&sdiodev->freezer->resumed);
+        atomic_set(&sdiodev->freezer->freezing, 1);
+        brcmf_sdio_trigger_dpc(sdiodev->bus);
+        wait_event(sdiodev->freezer->thread_freeze,
+                   atomic_read(expect) == sdiodev->freezer->frozen_count);
+        sdio_claim_host(sdiodev->func[1]);
+        res = brcmf_sdio_sleep(sdiodev->bus, true);
+        sdio_release_host(sdiodev->func[1]);
+        return res;
+}
+
+static void brcmf_sdiod_freezer_off(struct brcmf_sdio_dev *sdiodev)
+{
+        sdio_claim_host(sdiodev->func[1]);
+        brcmf_sdio_sleep(sdiodev->bus, false);
+        sdio_release_host(sdiodev->func[1]);
+        atomic_set(&sdiodev->freezer->freezing, 0);
+        complete_all(&sdiodev->freezer->resumed);
+}
+
+bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
+{
+        return atomic_read(&sdiodev->freezer->freezing);
+}
+
+void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
+{
+        if (!brcmf_sdiod_freezing(sdiodev))
+                return;
+        sdiodev->freezer->frozen_count++;
+        wake_up(&sdiodev->freezer->thread_freeze);
+        wait_for_completion(&sdiodev->freezer->resumed);
+}
+
+void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
+{
+        atomic_inc(&sdiodev->freezer->thread_count);
+}
+
+void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
+{
+        atomic_dec(&sdiodev->freezer->thread_count);
+}
+#else
+static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
+{
+        return 0;
+}
+
+static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
+{
+}
+#endif /* CONFIG_PM_SLEEP */
+
 static int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
 {
         if (sdiodev->bus) {
@@ -884,6 +991,8 @@ static int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
                 sdiodev->bus = NULL;
         }
 
+        brcmf_sdiod_freezer_detach(sdiodev);
+
         /* Disable Function 2 */
         sdio_claim_host(sdiodev->func[2]);
         sdio_disable_func(sdiodev->func[2]);
@@ -955,6 +1064,10 @@ static int brcmf_sdiod_probe(struct brcmf_sdio_dev *sdiodev)
          */
         brcmf_sdiod_sgtable_alloc(sdiodev);
 
+        ret = brcmf_sdiod_freezer_attach(sdiodev);
+        if (ret)
+                goto out;
+
         /* try to attach to the target device */
         sdiodev->bus = brcmf_sdio_probe(sdiodev);
         if (!sdiodev->bus) {
@@ -1050,9 +1163,7 @@ static int brcmf_ops_sdio_probe(struct sdio_func *func,
                 bus_if->wowl_supported = true;
 #endif
 
-        sdiodev->sleeping = false;
-        atomic_set(&sdiodev->suspend, false);
-        init_waitqueue_head(&sdiodev->idle_wait);
+        brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_DOWN);
 
         brcmf_dbg(SDIO, "F2 found, calling brcmf_sdiod_probe...\n");
         err = brcmf_sdiod_probe(sdiodev);
@@ -1114,24 +1225,22 @@ void brcmf_sdio_wowl_config(struct device *dev, bool enabled)
 #ifdef CONFIG_PM_SLEEP
 static int brcmf_ops_sdio_suspend(struct device *dev)
 {
+        struct sdio_func *func;
         struct brcmf_bus *bus_if;
         struct brcmf_sdio_dev *sdiodev;
         mmc_pm_flag_t sdio_flags;
 
-        brcmf_dbg(SDIO, "Enter\n");
+        func = container_of(dev, struct sdio_func, dev);
+        brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
+        if (func->num != SDIO_FUNC_1)
+                return 0;
+
 
         bus_if = dev_get_drvdata(dev);
         sdiodev = bus_if->bus_priv.sdio;
 
-        /* wait for watchdog to go idle */
-        if (wait_event_timeout(sdiodev->idle_wait, sdiodev->sleeping,
-                               msecs_to_jiffies(3 * BRCMF_WD_POLL_MS)) == 0) {
-                brcmf_err("bus still active\n");
-                return -EBUSY;
-        }
-        /* disable watchdog */
+        brcmf_sdiod_freezer_on(sdiodev);
         brcmf_sdio_wd_timer(sdiodev->bus, 0);
-        atomic_set(&sdiodev->suspend, true);
 
         if (sdiodev->wowl_enabled) {
                 sdio_flags = MMC_PM_KEEP_POWER;
@@ -1149,12 +1258,13 @@ static int brcmf_ops_sdio_resume(struct device *dev)
 {
         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
         struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
+        struct sdio_func *func = container_of(dev, struct sdio_func, dev);
 
-        brcmf_dbg(SDIO, "Enter\n");
-        if (sdiodev->pdata && sdiodev->pdata->oob_irq_supported)
-                disable_irq_wake(sdiodev->pdata->oob_irq_nr);
-        brcmf_sdio_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
-        atomic_set(&sdiodev->suspend, false);
+        brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
+        if (func->num != SDIO_FUNC_2)
+                return 0;
+
+        brcmf_sdiod_freezer_off(sdiodev);
         return 0;
 }
 
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c b/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c
index 06727a61b438..9b805c9fd51e 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/cfg80211.c
@@ -1050,10 +1050,6 @@ brcmf_cfg80211_escan(struct wiphy *wiphy, struct brcmf_cfg80211_vif *vif,
         if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
                 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
 
-        /* Arm scan timeout timer */
-        mod_timer(&cfg->escan_timeout, jiffies +
-                        WL_ESCAN_TIMER_INTERVAL_MS * HZ / 1000);
-
         escan_req = false;
         if (request) {
                 /* scan bss */
@@ -1112,12 +1108,14 @@ brcmf_cfg80211_escan(struct wiphy *wiphy, struct brcmf_cfg80211_vif *vif,
                 }
         }
 
+        /* Arm scan timeout timer */
+        mod_timer(&cfg->escan_timeout, jiffies +
+                        WL_ESCAN_TIMER_INTERVAL_MS * HZ / 1000);
+
         return 0;
 
 scan_out:
         clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
-        if (timer_pending(&cfg->escan_timeout))
-                del_timer_sync(&cfg->escan_timeout);
         cfg->scan_request = NULL;
         return err;
 }
@@ -2252,7 +2250,6 @@ brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
 
         if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) {
                 /* we ignore this key index in this case */
-                brcmf_err("invalid key index (%d)\n", key_idx);
                 return -EINVAL;
         }
 
@@ -4272,7 +4269,7 @@ brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev,
                 return -EIO;
 
         memcpy(&scbval.ea, params->mac, ETH_ALEN);
-        scbval.val = cpu_to_le32(WLAN_REASON_DEAUTH_LEAVING);
+        scbval.val = cpu_to_le32(params->reason_code);
         err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON,
                                      &scbval, sizeof(scbval));
         if (err)
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/core.c b/drivers/net/wireless/brcm80211/brcmfmac/core.c
index 2d6e2cc1b12c..f8f47dcfa886 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/core.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/core.c
@@ -944,6 +944,34 @@ fail:
         return ret;
 }
 
+static int brcmf_revinfo_read(struct seq_file *s, void *data)
+{
+        struct brcmf_bus *bus_if = dev_get_drvdata(s->private);
+        struct brcmf_rev_info *ri = &bus_if->drvr->revinfo;
+        char drev[BRCMU_DOTREV_LEN];
+        char brev[BRCMU_BOARDREV_LEN];
+
+        seq_printf(s, "vendorid: 0x%04x\n", ri->vendorid);
+        seq_printf(s, "deviceid: 0x%04x\n", ri->deviceid);
+        seq_printf(s, "radiorev: %s\n", brcmu_dotrev_str(ri->radiorev, drev));
+        seq_printf(s, "chipnum: %u (%x)\n", ri->chipnum, ri->chipnum);
+        seq_printf(s, "chiprev: %u\n", ri->chiprev);
+        seq_printf(s, "chippkg: %u\n", ri->chippkg);
+        seq_printf(s, "corerev: %u\n", ri->corerev);
+        seq_printf(s, "boardid: 0x%04x\n", ri->boardid);
+        seq_printf(s, "boardvendor: 0x%04x\n", ri->boardvendor);
+        seq_printf(s, "boardrev: %s\n", brcmu_boardrev_str(ri->boardrev, brev));
+        seq_printf(s, "driverrev: %s\n", brcmu_dotrev_str(ri->driverrev, drev));
+        seq_printf(s, "ucoderev: %u\n", ri->ucoderev);
+        seq_printf(s, "bus: %u\n", ri->bus);
+        seq_printf(s, "phytype: %u\n", ri->phytype);
+        seq_printf(s, "phyrev: %u\n", ri->phyrev);
+        seq_printf(s, "anarev: %u\n", ri->anarev);
+        seq_printf(s, "nvramrev: %08x\n", ri->nvramrev);
+
+        return 0;
+}
+
 int brcmf_bus_start(struct device *dev)
 {
         int ret = -1;
@@ -974,6 +1002,8 @@ int brcmf_bus_start(struct device *dev)
         if (ret < 0)
                 goto fail;
 
+        brcmf_debugfs_add_entry(drvr, "revinfo", brcmf_revinfo_read);
+
         /* assure we have chipid before feature attach */
         if (!bus_if->chip) {
                 bus_if->chip = drvr->revinfo.chipnum;
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/sdio.c b/drivers/net/wireless/brcm80211/brcmfmac/sdio.c
index faec35c899ec..257ee70feb5b 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/sdio.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/sdio.c
@@ -515,6 +515,7 @@ struct brcmf_sdio {
         bool txoff;             /* Transmit flow-controlled */
         struct brcmf_sdio_count sdcnt;
         bool sr_enabled; /* SaveRestore enabled */
+        bool sleeping;
 
         u8 tx_hdrlen;           /* sdio bus header length for tx packet */
         bool txglom;            /* host tx glomming enable flag */
@@ -1013,12 +1014,12 @@ brcmf_sdio_bus_sleep(struct brcmf_sdio *bus, bool sleep, bool pendok)
 
         brcmf_dbg(SDIO, "Enter: request %s currently %s\n",
                   (sleep ? "SLEEP" : "WAKE"),
-                  (bus->sdiodev->sleeping ? "SLEEP" : "WAKE"));
+                  (bus->sleeping ? "SLEEP" : "WAKE"));
 
         /* If SR is enabled control bus state with KSO */
         if (bus->sr_enabled) {
                 /* Done if we're already in the requested state */
-                if (sleep == bus->sdiodev->sleeping)
+                if (sleep == bus->sleeping)
                         goto end;
 
                 /* Going to sleep */
@@ -1026,6 +1027,7 @@ brcmf_sdio_bus_sleep(struct brcmf_sdio *bus, bool sleep, bool pendok)
                         /* Don't sleep if something is pending */
                         if (atomic_read(&bus->intstatus) ||
                             atomic_read(&bus->ipend) > 0 ||
+                            bus->ctrl_frame_stat ||
                             (!atomic_read(&bus->fcstate) &&
                             brcmu_pktq_mlen(&bus->txq, ~bus->flowcontrol) &&
                             data_ok(bus))) {
@@ -1065,9 +1067,7 @@ end:
         } else {
                 brcmf_sdio_clkctl(bus, CLK_AVAIL, pendok);
         }
-        bus->sdiodev->sleeping = sleep;
-        if (sleep)
-                wake_up(&bus->sdiodev->idle_wait);
+        bus->sleeping = sleep;
         brcmf_dbg(SDIO, "new state %s\n",
                   (sleep ? "SLEEP" : "WAKE"));
 done:
@@ -1909,7 +1909,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
         bus->rxpending = true;
 
         for (rd->seq_num = bus->rx_seq, rxleft = maxframes;
-             !bus->rxskip && rxleft && bus->sdiodev->state == BRCMF_STATE_DATA;
+             !bus->rxskip && rxleft && bus->sdiodev->state == BRCMF_SDIOD_DATA;
              rd->seq_num++, rxleft--) {
 
                 /* Handle glomming separately */
@@ -2415,7 +2415,7 @@ static uint brcmf_sdio_sendfromq(struct brcmf_sdio *bus, uint maxframes)
         }
 
         /* Deflow-control stack if needed */
-        if ((bus->sdiodev->state == BRCMF_STATE_DATA) &&
+        if ((bus->sdiodev->state == BRCMF_SDIOD_DATA) &&
             bus->txoff && (pktq_len(&bus->txq) < TXLOW)) {
                 bus->txoff = false;
                 brcmf_txflowblock(bus->sdiodev->dev, false);
@@ -2503,7 +2503,7 @@ static void brcmf_sdio_bus_stop(struct device *dev)
                 bus->watchdog_tsk = NULL;
         }
 
-        if (sdiodev->state != BRCMF_STATE_NOMEDIUM) {
+        if (sdiodev->state != BRCMF_SDIOD_NOMEDIUM) {
                 sdio_claim_host(sdiodev->func[1]);
 
                 /* Enable clock for device interrupts */
@@ -2603,21 +2603,6 @@ static int brcmf_sdio_intr_rstatus(struct brcmf_sdio *bus)
         return ret;
 }
 
-static int brcmf_sdio_pm_resume_wait(struct brcmf_sdio_dev *sdiodev)
-{
-#ifdef CONFIG_PM_SLEEP
-        int retry;
-
-        /* Wait for possible resume to complete */
-        retry = 0;
-        while ((atomic_read(&sdiodev->suspend)) && (retry++ != 50))
-                msleep(20);
-        if (atomic_read(&sdiodev->suspend))
-                return -EIO;
-#endif
-        return 0;
-}
-
 static void brcmf_sdio_dpc(struct brcmf_sdio *bus)
 {
         u32 newstatus = 0;
@@ -2628,9 +2613,6 @@ static void brcmf_sdio_dpc(struct brcmf_sdio *bus)
 
         brcmf_dbg(TRACE, "Enter\n");
 
-        if (brcmf_sdio_pm_resume_wait(bus->sdiodev))
-                return;
-
         sdio_claim_host(bus->sdiodev->func[1]);
 
         /* If waiting for HTAVAIL, check status */
@@ -2755,7 +2737,7 @@ static void brcmf_sdio_dpc(struct brcmf_sdio *bus)
                 brcmf_sdio_sendfromq(bus, framecnt);
         }
 
-        if ((bus->sdiodev->state != BRCMF_STATE_DATA) || (err != 0)) {
+        if ((bus->sdiodev->state != BRCMF_SDIOD_DATA) || (err != 0)) {
                 brcmf_err("failed backplane access over SDIO, halting operation\n");
                 atomic_set(&bus->intstatus, 0);
         } else if (atomic_read(&bus->intstatus) ||
@@ -2862,11 +2844,7 @@ static int brcmf_sdio_bus_txdata(struct device *dev, struct sk_buff *pkt)
                 qcount[prec] = pktq_plen(&bus->txq, prec);
 #endif
 
-        if (atomic_read(&bus->dpc_tskcnt) == 0) {
-                atomic_inc(&bus->dpc_tskcnt);
-                queue_work(bus->brcmf_wq, &bus->datawork);
-        }
-
+        brcmf_sdio_trigger_dpc(bus);
         return ret;
 }
 
@@ -2964,11 +2942,8 @@ brcmf_sdio_bus_txctl(struct device *dev, unsigned char *msg, uint msglen)
         bus->ctrl_frame_buf = msg;
         bus->ctrl_frame_len = msglen;
         bus->ctrl_frame_stat = true;
-        if (atomic_read(&bus->dpc_tskcnt) == 0) {
-                atomic_inc(&bus->dpc_tskcnt);
-                queue_work(bus->brcmf_wq, &bus->datawork);
-        }
 
+        brcmf_sdio_trigger_dpc(bus);
         wait_event_interruptible_timeout(bus->ctrl_wait, !bus->ctrl_frame_stat,
                                          msecs_to_jiffies(CTL_DONE_TIMEOUT));
 
@@ -3411,7 +3386,7 @@ static int brcmf_sdio_download_firmware(struct brcmf_sdio *bus,
         }
 
         /* Allow full data communication using DPC from now on. */
-        bus->sdiodev->state = BRCMF_STATE_DATA;
+        brcmf_sdiod_change_state(bus->sdiodev, BRCMF_SDIOD_DATA);
         bcmerror = 0;
 
 err:
@@ -3548,6 +3523,14 @@ done:
         return err;
 }
 
+void brcmf_sdio_trigger_dpc(struct brcmf_sdio *bus)
+{
+        if (atomic_read(&bus->dpc_tskcnt) == 0) {
+                atomic_inc(&bus->dpc_tskcnt);
+                queue_work(bus->brcmf_wq, &bus->datawork);
+        }
+}
+
 void brcmf_sdio_isr(struct brcmf_sdio *bus)
 {
         brcmf_dbg(TRACE, "Enter\n");
@@ -3557,7 +3540,7 @@ void brcmf_sdio_isr(struct brcmf_sdio *bus)
                 return;
         }
 
-        if (bus->sdiodev->state != BRCMF_STATE_DATA) {
+        if (bus->sdiodev->state != BRCMF_SDIOD_DATA) {
                 brcmf_err("bus is down. we have nothing to do\n");
                 return;
         }
@@ -3602,9 +3585,8 @@ static bool brcmf_sdio_bus_watchdog(struct brcmf_sdio *bus)
                                                             SDIO_CCCR_INTx,
                                                             NULL);
                                 sdio_release_host(bus->sdiodev->func[1]);
-                                intstatus =
-                                    devpend & (INTR_STATUS_FUNC1 |
-                                               INTR_STATUS_FUNC2);
+                                intstatus = devpend & (INTR_STATUS_FUNC1 |
+                                                       INTR_STATUS_FUNC2);
                         }
 
                         /* If there is something, make like the ISR and
@@ -3623,7 +3605,7 @@ static bool brcmf_sdio_bus_watchdog(struct brcmf_sdio *bus)
         }
 #ifdef DEBUG
         /* Poll for console output periodically */
-        if (bus->sdiodev->state == BRCMF_STATE_DATA &&
+        if (bus->sdiodev->state == BRCMF_SDIOD_DATA &&
             bus->console_interval != 0) {
                 bus->console.count += BRCMF_WD_POLL_MS;
                 if (bus->console.count >= bus->console_interval) {
@@ -3667,6 +3649,11 @@ static void brcmf_sdio_dataworker(struct work_struct *work)
                 atomic_set(&bus->dpc_tskcnt, 0);
                 brcmf_sdio_dpc(bus);
         }
+        if (brcmf_sdiod_freezing(bus->sdiodev)) {
+                brcmf_sdiod_change_state(bus->sdiodev, BRCMF_SDIOD_DOWN);
+                brcmf_sdiod_try_freeze(bus->sdiodev);
+                brcmf_sdiod_change_state(bus->sdiodev, BRCMF_SDIOD_DATA);
+        }
 }
 
 static void
@@ -3944,13 +3931,19 @@ static int
 brcmf_sdio_watchdog_thread(void *data)
 {
         struct brcmf_sdio *bus = (struct brcmf_sdio *)data;
+        int wait;
 
         allow_signal(SIGTERM);
         /* Run until signal received */
+        brcmf_sdiod_freezer_count(bus->sdiodev);
         while (1) {
                 if (kthread_should_stop())
                         break;
-                if (!wait_for_completion_interruptible(&bus->watchdog_wait)) {
+                brcmf_sdiod_freezer_uncount(bus->sdiodev);
+                wait = wait_for_completion_interruptible(&bus->watchdog_wait);
+                brcmf_sdiod_freezer_count(bus->sdiodev);
+                brcmf_sdiod_try_freeze(bus->sdiodev);
+                if (!wait) {
                         brcmf_sdio_bus_watchdog(bus);
                         /* Count the tick for reference */
                         bus->sdcnt.tickcnt++;
@@ -3971,7 +3964,7 @@ brcmf_sdio_watchdog(unsigned long data)
                 /* Reschedule the watchdog */
                 if (bus->wd_timer_valid)
                         mod_timer(&bus->timer,
-                                  jiffies + BRCMF_WD_POLL_MS * HZ / 1000);
+                                  jiffies + msecs_to_jiffies(BRCMF_WD_POLL_MS));
         }
 }
 
@@ -4089,6 +4082,7 @@ struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
 {
         int ret;
         struct brcmf_sdio *bus;
+        struct workqueue_struct *wq;
 
         brcmf_dbg(TRACE, "Enter\n");
 
@@ -4117,12 +4111,16 @@ struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
                         bus->sgentry_align = sdiodev->pdata->sd_sgentry_align;
         }
 
-        INIT_WORK(&bus->datawork, brcmf_sdio_dataworker);
-        bus->brcmf_wq = create_singlethread_workqueue("brcmf_wq");
-        if (bus->brcmf_wq == NULL) {
+        /* single-threaded workqueue */
+        wq = alloc_ordered_workqueue("brcmf_wq/%s", WQ_MEM_RECLAIM,
+                                     dev_name(&sdiodev->func[1]->dev));
+        if (!wq) {
                 brcmf_err("insufficient memory to create txworkqueue\n");
                 goto fail;
         }
+        brcmf_sdiod_freezer_count(sdiodev);
+        INIT_WORK(&bus->datawork, brcmf_sdio_dataworker);
+        bus->brcmf_wq = wq;
 
         /* attempt to attach to the dongle */
         if (!(brcmf_sdio_probe_attach(bus))) {
@@ -4143,7 +4141,8 @@ struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
         /* Initialize watchdog thread */
         init_completion(&bus->watchdog_wait);
         bus->watchdog_tsk = kthread_run(brcmf_sdio_watchdog_thread,
-                                        bus, "brcmf_watchdog");
+                                        bus, "brcmf_wdog/%s",
+                                        dev_name(&sdiodev->func[1]->dev));
         if (IS_ERR(bus->watchdog_tsk)) {
                 pr_warn("brcmf_watchdog thread failed to start\n");
                 bus->watchdog_tsk = NULL;
@@ -4242,7 +4241,7 @@ void brcmf_sdio_remove(struct brcmf_sdio *bus)
                         destroy_workqueue(bus->brcmf_wq);
 
                 if (bus->ci) {
-                        if (bus->sdiodev->state != BRCMF_STATE_NOMEDIUM) {
+                        if (bus->sdiodev->state != BRCMF_SDIOD_NOMEDIUM) {
                                 sdio_claim_host(bus->sdiodev->func[1]);
                                 brcmf_sdio_clkctl(bus, CLK_AVAIL, false);
                                 /* Leave the device in state where it is
@@ -4277,7 +4276,7 @@ void brcmf_sdio_wd_timer(struct brcmf_sdio *bus, uint wdtick)
         }
 
         /* don't start the wd until fw is loaded */
-        if (bus->sdiodev->state != BRCMF_STATE_DATA)
+        if (bus->sdiodev->state != BRCMF_SDIOD_DATA)
                 return;
 
         if (wdtick) {
@@ -4290,16 +4289,28 @@ void brcmf_sdio_wd_timer(struct brcmf_sdio *bus, uint wdtick)
                            dynamically changed or in the first instance
                          */
                         bus->timer.expires =
-                                jiffies + BRCMF_WD_POLL_MS * HZ / 1000;
+                                jiffies + msecs_to_jiffies(BRCMF_WD_POLL_MS);
                         add_timer(&bus->timer);
 
                 } else {
                         /* Re arm the timer, at last watchdog period */
                         mod_timer(&bus->timer,
-                                jiffies + BRCMF_WD_POLL_MS * HZ / 1000);
+                                jiffies + msecs_to_jiffies(BRCMF_WD_POLL_MS));
                 }
 
                 bus->wd_timer_valid = true;
                 bus->save_ms = wdtick;
         }
 }
+
+int brcmf_sdio_sleep(struct brcmf_sdio *bus, bool sleep)
+{
+        int ret;
+
+        sdio_claim_host(bus->sdiodev->func[1]);
+        ret = brcmf_sdio_bus_sleep(bus, sleep, false);
+        sdio_release_host(bus->sdiodev->func[1]);
+
+        return ret;
+}
+
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/sdio.h b/drivers/net/wireless/brcm80211/brcmfmac/sdio.h
index ec2586a8425c..7328478b2d7b 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/sdio.h
+++ b/drivers/net/wireless/brcm80211/brcmfmac/sdio.h
@@ -155,11 +155,17 @@
 /* watchdog polling interval in ms */
 #define BRCMF_WD_POLL_MS        10
 
-/* The state of the bus */
-enum brcmf_sdio_state {
-        BRCMF_STATE_DOWN,       /* Device available, still initialising */
-        BRCMF_STATE_DATA,       /* Ready for data transfers, DPC enabled */
-        BRCMF_STATE_NOMEDIUM    /* No medium access to dongle possible */
+/**
+ * enum brcmf_sdiod_state - the state of the bus.
+ *
+ * @BRCMF_SDIOD_DOWN: Device can be accessed, no DPC.
+ * @BRCMF_SDIOD_DATA: Ready for data transfers, DPC enabled.
+ * @BRCMF_SDIOD_NOMEDIUM: No medium access to dongle possible.
+ */
+enum brcmf_sdiod_state {
+        BRCMF_SDIOD_DOWN,
+        BRCMF_SDIOD_DATA,
+        BRCMF_SDIOD_NOMEDIUM
 };
 
 struct brcmf_sdreg {
@@ -169,15 +175,13 @@ struct brcmf_sdreg {
 };
 
 struct brcmf_sdio;
+struct brcmf_sdiod_freezer;
 
 struct brcmf_sdio_dev {
         struct sdio_func *func[SDIO_MAX_FUNCS];
         u8 num_funcs;                   /* Supported funcs on client */
         u32 sbwad;                      /* Save backplane window address */
         struct brcmf_sdio *bus;
-        atomic_t suspend;               /* suspend flag */
-        bool sleeping;
-        wait_queue_head_t idle_wait;
         struct device *dev;
         struct brcmf_bus *bus_if;
         struct brcmfmac_sdio_platform_data *pdata;
@@ -194,7 +198,8 @@ struct brcmf_sdio_dev {
         char fw_name[BRCMF_FW_PATH_LEN + BRCMF_FW_NAME_LEN];
         char nvram_name[BRCMF_FW_PATH_LEN + BRCMF_FW_NAME_LEN];
         bool wowl_enabled;
-        enum brcmf_sdio_state state;
+        enum brcmf_sdiod_state state;
+        struct brcmf_sdiod_freezer *freezer;
 };
 
 /* sdio core registers */
@@ -337,6 +342,28 @@ int brcmf_sdiod_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
 
 /* Issue an abort to the specified function */
 int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, uint fn);
+void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
+                              enum brcmf_sdiod_state state);
+#ifdef CONFIG_PM_SLEEP
+bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev);
+void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev);
+void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev);
+void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev);
+#else
+static inline bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
+{
+        return false;
+}
+static inline void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
+{
+}
+static inline void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
+{
+}
+static inline void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
+{
+}
+#endif /* CONFIG_PM_SLEEP */
 
 struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev);
 void brcmf_sdio_remove(struct brcmf_sdio *bus);
@@ -344,5 +371,7 @@ void brcmf_sdio_isr(struct brcmf_sdio *bus);
 
 void brcmf_sdio_wd_timer(struct brcmf_sdio *bus, uint wdtick);
 void brcmf_sdio_wowl_config(struct device *dev, bool enabled);
+int brcmf_sdio_sleep(struct brcmf_sdio *bus, bool sleep);
+void brcmf_sdio_trigger_dpc(struct brcmf_sdio *bus);
 
 #endif /* BRCMFMAC_SDIO_H */