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)
 {
        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)
 {
        s32 retry = 0;
        int ret;
 
-       if (sdiodev->state == BRCMF_STATE_NOMEDIUM)
+       if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
                return -ENOMEDIUM;
 
        /*
                 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
        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;
                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;
 }
 
 
                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",
                bus_if->wowl_supported = true;
 #endif
 
+       brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_DOWN);
        sdiodev->sleeping = false;
        atomic_set(&sdiodev->suspend, false);
        init_waitqueue_head(&sdiodev->idle_wait);
 
        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 */
        }
 
        /* 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);
                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 */
                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) ||
        }
 
        /* 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:
                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;
        }
        }
 #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) {
                        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
        }
 
        /* 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) {
 
 /* 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 {
        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;
 };
 
 /* sdio core registers */
 void brcmf_sdio_wd_timer(struct brcmf_sdio *bus, uint wdtick);
 void brcmf_sdio_wowl_config(struct device *dev, bool enabled);
 
+void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
+                             enum brcmf_sdiod_state state);
+
 #endif /* BRCMFMAC_SDIO_H */