u8 data;
        unsigned long flags;
 
-       brcmf_dbg(TRACE, "Entering: irq %d\n", sdiodev->irq);
+       brcmf_dbg(SDIO, "Entering: irq %d\n", sdiodev->irq);
 
        ret = request_irq(sdiodev->irq, brcmf_sdio_irqhandler,
                          sdiodev->irq_flags, "brcmf_oob_intr",
 
 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
 {
-       brcmf_dbg(TRACE, "Entering\n");
+       brcmf_dbg(SDIO, "Entering\n");
 
        sdio_claim_host(sdiodev->func[1]);
        brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
 
 int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
 {
-       brcmf_dbg(TRACE, "Entering\n");
+       brcmf_dbg(SDIO, "Entering\n");
 
        sdio_claim_host(sdiodev->func[1]);
        sdio_claim_irq(sdiodev->func[1], brcmf_sdio_irqhandler);
 
 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
 {
-       brcmf_dbg(TRACE, "Entering\n");
+       brcmf_dbg(SDIO, "Entering\n");
 
        sdio_claim_host(sdiodev->func[1]);
        sdio_release_irq(sdiodev->func[2]);
        u8 data;
        int retval;
 
-       brcmf_dbg(INFO, "addr:0x%08x\n", addr);
+       brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
        retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
-       brcmf_dbg(INFO, "data:0x%02x\n", data);
+       brcmf_dbg(SDIO, "data:0x%02x\n", data);
 
        if (ret)
                *ret = retval;
        u32 data;
        int retval;
 
-       brcmf_dbg(INFO, "addr:0x%08x\n", addr);
+       brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
        retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
-       brcmf_dbg(INFO, "data:0x%08x\n", data);
+       brcmf_dbg(SDIO, "data:0x%08x\n", data);
 
        if (ret)
                *ret = retval;
 {
        int retval;
 
-       brcmf_dbg(INFO, "addr:0x%08x, data:0x%02x\n", addr, data);
+       brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data);
        retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
 
        if (ret)
 {
        int retval;
 
-       brcmf_dbg(INFO, "addr:0x%08x, data:0x%08x\n", addr, data);
+       brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data);
        retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
 
        if (ret)
        uint width;
        int err = 0;
 
-       brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
+       brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n",
                  fn, addr, pkt->len);
 
        width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
        uint width;
        int err = 0;
 
-       brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
+       brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n",
                  fn, addr, pktq->qlen);
 
        width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
        uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
        int err = 0;
 
-       brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
+       brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n",
                  fn, addr, pkt->len);
 
        /* Async not implemented yet */
 int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
 {
        char t_func = (char)fn;
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        /* issue abort cmd52 command through F0 */
        brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
                                 SDIO_CCCR_ABORT, &t_func);
 
-       brcmf_dbg(TRACE, "Exit\n");
+       brcmf_dbg(SDIO, "Exit\n");
        return 0;
 }
 
 
 {
        int err_ret;
 
-       brcmf_dbg(INFO, "rw=%d, func=%d, addr=0x%05x\n", rw, func, regaddr);
+       brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x\n", rw, func, regaddr);
 
        brcmf_pm_resume_wait(sdiodev, &sdiodev->request_byte_wait);
        if (brcmf_pm_resume_error(sdiodev))
                return -EINVAL;
        }
 
-       brcmf_dbg(INFO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
+       brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
                  rw, func, addr, nbytes);
 
        brcmf_pm_resume_wait(sdiodev, &sdiodev->request_word_wait);
 
        struct sk_buff *pkt;
 
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        brcmf_pm_resume_wait(sdiodev, &sdiodev->request_chain_wait);
        if (brcmf_pm_resume_error(sdiodev))
                                  write ? "TX" : "RX", pkt, SGCount, addr,
                                  pkt_len, err_ret);
                } else {
-                       brcmf_dbg(TRACE, "%s xfr'd %p[%d], addr=0x%05x, len=%d\n",
+                       brcmf_dbg(SDIO, "%s xfr'd %p[%d], addr=0x%05x, len=%d\n",
                                  write ? "TX" : "RX", pkt, SGCount, addr,
                                  pkt_len);
                }
                SGCount++;
        }
 
-       brcmf_dbg(TRACE, "Exit\n");
+       brcmf_dbg(SDIO, "Exit\n");
        return err_ret;
 }
 
        uint pkt_len;
        bool fifo = (fix_inc == SDIOH_DATA_FIX);
 
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        if (pkt == NULL)
                return -EINVAL;
                brcmf_err("%s FAILED %p, addr=0x%05x, pkt_len=%d, ERR=0x%08x\n",
                          write ? "TX" : "RX", pkt, addr, pkt_len, status);
        } else {
-               brcmf_dbg(TRACE, "%s xfr'd %p, addr=0x%05x, len=%d\n",
+               brcmf_dbg(SDIO, "%s xfr'd %p, addr=0x%05x, len=%d\n",
                          write ? "TX" : "RX", pkt, addr, pkt_len);
        }
 
        u32 fbraddr;
        u8 func;
 
-       brcmf_dbg(TRACE, "\n");
+       brcmf_dbg(SDIO, "\n");
 
        /* Get the Card's common CIS address */
        sdiodev->func_cis_ptr[0] = brcmf_sdioh_get_cisaddr(sdiodev,
                                                           SDIO_CCCR_CIS);
-       brcmf_dbg(INFO, "Card's Common CIS Ptr = 0x%x\n",
+       brcmf_dbg(SDIO, "Card's Common CIS Ptr = 0x%x\n",
                  sdiodev->func_cis_ptr[0]);
 
        /* Get the Card's function CIS (for each function) */
             func <= sdiodev->num_funcs; func++, fbraddr += SDIOD_FBR_SIZE) {
                sdiodev->func_cis_ptr[func] =
                    brcmf_sdioh_get_cisaddr(sdiodev, SDIO_FBR_CIS + fbraddr);
-               brcmf_dbg(INFO, "Function %d CIS Ptr = 0x%x\n",
+               brcmf_dbg(SDIO, "Function %d CIS Ptr = 0x%x\n",
                          func, sdiodev->func_cis_ptr[func]);
        }
 
 {
        int err_ret = 0;
 
-       brcmf_dbg(TRACE, "\n");
+       brcmf_dbg(SDIO, "\n");
 
        sdiodev->num_funcs = 2;
 
 
 out:
        sdio_release_host(sdiodev->func[1]);
-       brcmf_dbg(TRACE, "Done\n");
+       brcmf_dbg(SDIO, "Done\n");
        return err_ret;
 }
 
 void brcmf_sdioh_detach(struct brcmf_sdio_dev *sdiodev)
 {
-       brcmf_dbg(TRACE, "\n");
+       brcmf_dbg(SDIO, "\n");
 
        /* Disable Function 2 */
        sdio_claim_host(sdiodev->func[2]);
        struct brcmf_sdio_dev *sdiodev;
        struct brcmf_bus *bus_if;
 
-       brcmf_dbg(TRACE, "Enter\n");
-       brcmf_dbg(TRACE, "Class=%x\n", func->class);
-       brcmf_dbg(TRACE, "sdio vendor ID: 0x%04x\n", func->vendor);
-       brcmf_dbg(TRACE, "sdio device ID: 0x%04x\n", func->device);
-       brcmf_dbg(TRACE, "Function#: %d\n", func->num);
+       brcmf_dbg(SDIO, "Enter\n");
+       brcmf_dbg(SDIO, "Class=%x\n", func->class);
+       brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
+       brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
+       brcmf_dbg(SDIO, "Function#: %d\n", func->num);
 
        /* Consume func num 1 but dont do anything with it. */
        if (func->num == 1)
        if (err)
                goto fail;
 
-       brcmf_dbg(TRACE, "F2 found, calling brcmf_sdio_probe...\n");
+       brcmf_dbg(SDIO, "F2 found, calling brcmf_sdio_probe...\n");
        err = brcmf_sdio_probe(sdiodev);
        if (err) {
                brcmf_err("F2 error, probe failed %d...\n", err);
                goto fail;
        }
-       brcmf_dbg(TRACE, "F2 init completed...\n");
+       brcmf_dbg(SDIO, "F2 init completed...\n");
        return 0;
 
 fail:
        struct brcmf_bus *bus_if;
        struct brcmf_sdio_dev *sdiodev;
 
-       brcmf_dbg(TRACE, "Enter\n");
-       brcmf_dbg(TRACE, "sdio vendor ID: 0x%04x\n", func->vendor);
-       brcmf_dbg(TRACE, "sdio device ID: 0x%04x\n", func->device);
-       brcmf_dbg(TRACE, "Function: %d\n", func->num);
+       brcmf_dbg(SDIO, "Enter\n");
+       brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
+       brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
+       brcmf_dbg(SDIO, "Function: %d\n", func->num);
 
        if (func->num != 1 && func->num != 2)
                return;
                kfree(sdiodev);
        }
 
-       brcmf_dbg(TRACE, "Exit\n");
+       brcmf_dbg(SDIO, "Exit\n");
 }
 
 #ifdef CONFIG_PM_SLEEP
        struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
        int ret = 0;
 
-       brcmf_dbg(TRACE, "\n");
+       brcmf_dbg(SDIO, "\n");
 
        atomic_set(&sdiodev->suspend, true);
 
 
 void brcmf_sdio_exit(void)
 {
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        sdio_unregister_driver(&brcmf_sdmmc_driver);
 
 {
        int ret;
 
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        ret = platform_driver_register(&brcmf_sdio_pd);
 
 #else
 void brcmf_sdio_exit(void)
 {
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        sdio_unregister_driver(&brcmf_sdmmc_driver);
 }
 {
        int ret;
 
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        ret = sdio_register_driver(&brcmf_sdmmc_driver);
 
 
 #define BRCMF_SCAN_VAL 0x00004000
 #define BRCMF_CONN_VAL 0x00008000
 #define BRCMF_CDC_VAL  0x00010000
+#define BRCMF_SDIO_VAL 0x00020000
 
 /* set default print format */
 #undef pr_fmt
 
        u8 clkctl, clkreq, devctl;
        unsigned long timeout;
 
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        clkctl = 0;
 
                        devctl |= SBSDIO_DEVCTL_CA_INT_ONLY;
                        brcmf_sdio_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL,
                                         devctl, &err);
-                       brcmf_dbg(INFO, "CLKCTL: set PENDING\n");
+                       brcmf_dbg(SDIO, "CLKCTL: set PENDING\n");
                        bus->clkstate = CLK_PENDING;
 
                        return 0;
 
                /* Mark clock available */
                bus->clkstate = CLK_AVAIL;
-               brcmf_dbg(INFO, "CLKCTL: turned ON\n");
+               brcmf_dbg(SDIO, "CLKCTL: turned ON\n");
 
 #if defined(DEBUG)
                if (!bus->alp_only) {
                bus->clkstate = CLK_SDONLY;
                brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
                                 clkreq, &err);
-               brcmf_dbg(INFO, "CLKCTL: turned OFF\n");
+               brcmf_dbg(SDIO, "CLKCTL: turned OFF\n");
                if (err) {
                        brcmf_err("Failed access turning clock off: %d\n",
                                  err);
 /* Change idle/active SD state */
 static int brcmf_sdbrcm_sdclk(struct brcmf_sdio *bus, bool on)
 {
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        if (on)
                bus->clkstate = CLK_SDONLY;
        uint oldstate = bus->clkstate;
 #endif                         /* DEBUG */
 
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        /* Early exit if we're already there */
        if (bus->clkstate == target) {
                break;
        }
 #ifdef DEBUG
-       brcmf_dbg(INFO, "%d -> %d\n", oldstate, bus->clkstate);
+       brcmf_dbg(SDIO, "%d -> %d\n", oldstate, bus->clkstate);
 #endif                         /* DEBUG */
 
        return 0;
        u8 fcbits;
        int ret;
 
-       brcmf_dbg(TRACE, "Enter\n");
+       brcmf_dbg(SDIO, "Enter\n");
 
        /* Read mailbox data and ack that we did so */
        ret = r_sdreg32(bus, &hmb_data,
 
        /* Dongle recomposed rx frames, accept them again */
        if (hmb_data & HMB_DATA_NAKHANDLED) {
-               brcmf_dbg(INFO, "Dongle reports NAK handled, expect rtx of %d\n",
+               brcmf_dbg(SDIO, "Dongle reports NAK handled, expect rtx of %d\n",
                          bus->rx_seq);
                if (!bus->rxskip)
                        brcmf_err("unexpected NAKHANDLED!\n");
                                  "expecting %d\n",
                                  bus->sdpcm_ver, SDPCM_PROT_VERSION);
                else
-                       brcmf_dbg(INFO, "Dongle ready, protocol version %d\n",
+                       brcmf_dbg(SDIO, "Dongle ready, protocol version %d\n",
                                  bus->sdpcm_ver);
        }
 
        if (!retries)
                brcmf_err("count never zeroed: last 0x%04x\n", lastrbc);
        else
-               brcmf_dbg(INFO, "flush took %d iterations\n", 0xffff - retries);
+               brcmf_dbg(SDIO, "flush took %d iterations\n", 0xffff - retries);
 
        if (rtx) {
                bus->sdcnt.rxrtx++;
        /* If packets, issue read(s) and send up packet chain */
        /* Return sequence numbers consumed? */
 
-       brcmf_dbg(TRACE, "start: glomd %p glom %p\n",
+       brcmf_dbg(SDIO, "start: glomd %p glom %p\n",
                  bus->glomd, skb_peek(&bus->glom));
 
        /* If there's a descriptor, generate the packet chain */
                        bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN;
                }
 
-               brcmf_dbg(INFO, "DPC: PENDING, devctl 0x%02x clkctl 0x%02x\n",
+               brcmf_dbg(SDIO, "DPC: PENDING, devctl 0x%02x clkctl 0x%02x\n",
                          devctl, clkctl);
 
                if (SBSDIO_HTAV(clkctl)) {
 
        /* Do the transfer(s) */
        while (size) {
-               brcmf_dbg(INFO, "%s %d bytes at offset 0x%08x in window 0x%08x\n",
+               brcmf_dbg(SDIO, "%s %d bytes at offset 0x%08x in window 0x%08x\n",
                          write ? "write" : "read", dsize,
                          sdaddr, address & SBSDIO_SBWINDOW_MASK);
                bcmerror = brcmf_sdcard_rwdata(bus->sdiodev, write,
                                                 msecs_to_jiffies(2000));
 
                if (!bus->ctrl_frame_stat) {
-                       brcmf_dbg(INFO, "ctrl_frame_stat == false\n");
+                       brcmf_dbg(SDIO, "ctrl_frame_stat == false\n");
                        ret = 0;
                } else {
-                       brcmf_dbg(INFO, "ctrl_frame_stat == true\n");
+                       brcmf_dbg(SDIO, "ctrl_frame_stat == true\n");
                        ret = -1;
                }
        }
 
        addr = le32_to_cpu(addr_le);
 
-       brcmf_dbg(INFO, "sdpcm_shared address 0x%08X\n", addr);
+       brcmf_dbg(SDIO, "sdpcm_shared address 0x%08X\n", addr);
 
        /*
         * Check if addr is valid.