uint *msg_level;        /* message level pointer */
        char name[MAXNAMEL];    /* callers name for diag msgs */
 
-       struct pci_dev *pbus;           /* bus handle */
+       struct bcma_device *d11core;
+       struct device *dmadev;
 
        bool dma64;     /* this dma engine is operating in 64-bit mode */
        bool addrext;   /* this dma engine supports DmaExtendedAddrChanges */
  * Descriptor table must start at the DMA hardware dictated alignment, so
  * allocated memory must be large enough to support this requirement.
  */
-static void *dma_alloc_consistent(struct pci_dev *pdev, uint size,
+static void *dma_alloc_consistent(struct dma_info *di, uint size,
                                  u16 align_bits, uint *alloced,
                                  dma_addr_t *pap)
 {
                        size += align;
                *alloced = size;
        }
-       return pci_alloc_consistent(pdev, size, pap);
+       return dma_alloc_coherent(di->dmadev, size, pap, GFP_ATOMIC);
 }
 
 static
        u32 desc_strtaddr;
        u32 alignbytes = 1 << *alignbits;
 
-       va = dma_alloc_consistent(di->pbus, size, *alignbits, alloced, descpa);
+       va = dma_alloc_consistent(di, size, *alignbits, alloced, descpa);
 
        if (NULL == va)
                return NULL;
        if (((desc_strtaddr + size - 1) & boundary) != (desc_strtaddr
                                                        & boundary)) {
                *alignbits = dma_align_sizetobits(size);
-               pci_free_consistent(di->pbus, size, va, *descpa);
-               va = dma_alloc_consistent(di->pbus, size, *alignbits,
+               dma_free_coherent(di->dmadev, size, va, *descpa);
+               va = dma_alloc_consistent(di, size, *alignbits,
                        alloced, descpa);
        }
        return va;
 }
 
 struct dma_pub *dma_attach(char *name, struct si_pub *sih,
-                    void __iomem *dmaregstx, void __iomem *dmaregsrx,
-                    uint ntxd, uint nrxd,
-                    uint rxbufsize, int rxextheadroom,
-                    uint nrxpost, uint rxoffset, uint *msg_level)
+                          struct bcma_device *d11core,
+                          void __iomem *dmaregstx, void __iomem *dmaregsrx,
+                          uint ntxd, uint nrxd,
+                          uint rxbufsize, int rxextheadroom,
+                          uint nrxpost, uint rxoffset, uint *msg_level)
 {
        struct dma_info *di;
        uint size;
        di->dma64 = ((ai_core_sflags(sih, 0, 0) & SISF_DMA64) == SISF_DMA64);
 
        /* init dma reg pointer */
+       di->d11core = d11core;
        di->d64txregs = (struct dma64regs __iomem *) dmaregstx;
        di->d64rxregs = (struct dma64regs __iomem *) dmaregsrx;
 
        strncpy(di->name, name, MAXNAMEL);
        di->name[MAXNAMEL - 1] = '\0';
 
-       di->pbus = ((struct si_info *)sih)->pcibus;
+       di->dmadev = d11core->dma_dev;
 
        /* save tunables */
        di->ntxd = (u16) ntxd;
 
        /* free dma descriptor rings */
        if (di->txd64)
-               pci_free_consistent(di->pbus, di->txdalloc,
-                                   ((s8 *)di->txd64 - di->txdalign),
-                                   (di->txdpaorig));
+               dma_free_coherent(di->dmadev, di->txdalloc,
+                                 ((s8 *)di->txd64 - di->txdalign),
+                                 (di->txdpaorig));
        if (di->rxd64)
-               pci_free_consistent(di->pbus, di->rxdalloc,
-                                   ((s8 *)di->rxd64 - di->rxdalign),
-                                   (di->rxdpaorig));
+               dma_free_coherent(di->dmadev, di->rxdalloc,
+                                 ((s8 *)di->rxd64 - di->rxdalign),
+                                 (di->rxdpaorig));
 
        /* free packet pointer vectors */
        kfree(di->txp);
        pa = le32_to_cpu(di->rxd64[i].addrlow) - di->dataoffsetlow;
 
        /* clear this packet from the descriptor ring */
-       pci_unmap_single(di->pbus, pa, di->rxbufsize, PCI_DMA_FROMDEVICE);
+       dma_unmap_single(di->dmadev, pa, di->rxbufsize, DMA_FROM_DEVICE);
 
        di->rxd64[i].addrlow = cpu_to_le32(0xdeadbeef);
        di->rxd64[i].addrhigh = cpu_to_le32(0xdeadbeef);
                 */
                *(u32 *) (p->data) = 0;
 
-               pa = pci_map_single(di->pbus, p->data,
-                       di->rxbufsize, PCI_DMA_FROMDEVICE);
+               pa = dma_map_single(di->dmadev, p->data, di->rxbufsize,
+                                   DMA_FROM_DEVICE);
 
                /* save the free packet pointer */
                di->rxp[rxout] = p;
                goto outoftxd;
 
        /* get physical address of buffer start */
-       pa = pci_map_single(di->pbus, data, len, PCI_DMA_TODEVICE);
+       pa = dma_map_single(di->dmadev, data, len, DMA_TO_DEVICE);
 
        /* With a DMA segment list, Descriptor table is filled
         * using the segment list instead of looping over
                txp = di->txp[i];
                di->txp[i] = NULL;
 
-               pci_unmap_single(di->pbus, pa, size, PCI_DMA_TODEVICE);
+               dma_unmap_single(di->dmadev, pa, size, DMA_TO_DEVICE);
        }
 
        di->txin = i;
 
                 * TX: TX_AC_BK_FIFO (TX AC Background data packets)
                 * RX: RX_FIFO (RX data packets)
                 */
-               wlc_hw->di[0] = dma_attach(name, wlc_hw->sih,
+               wlc_hw->di[0] = dma_attach(name, wlc_hw->sih, wlc_hw->d11core,
                                           (wme ? dmareg(wlc_hw, DMA_TX, 0) :
                                            NULL), dmareg(wlc_hw, DMA_RX, 0),
                                           (wme ? NTXD : 0), NRXD,
                 *   (legacy) TX_DATA_FIFO (TX data packets)
                 * RX: UNUSED
                 */
-               wlc_hw->di[1] = dma_attach(name, wlc_hw->sih,
+               wlc_hw->di[1] = dma_attach(name, wlc_hw->sih, wlc_hw->d11core,
                                           dmareg(wlc_hw, DMA_TX, 1), NULL,
                                           NTXD, 0, 0, -1, 0, 0,
                                           &brcm_msg_level);
                 * TX: TX_AC_VI_FIFO (TX AC Video data packets)
                 * RX: UNUSED
                 */
-               wlc_hw->di[2] = dma_attach(name, wlc_hw->sih,
+               wlc_hw->di[2] = dma_attach(name, wlc_hw->sih, wlc_hw->d11core,
                                           dmareg(wlc_hw, DMA_TX, 2), NULL,
                                           NTXD, 0, 0, -1, 0, 0,
                                           &brcm_msg_level);
                 * TX: TX_AC_VO_FIFO (TX AC Voice data packets)
                 *   (legacy) TX_CTL_FIFO (TX control & mgmt packets)
                 */
-               wlc_hw->di[3] = dma_attach(name, wlc_hw->sih,
+               wlc_hw->di[3] = dma_attach(name, wlc_hw->sih, wlc_hw->d11core,
                                           dmareg(wlc_hw, DMA_TX, 3),
                                           NULL, NTXD, 0, 0, -1,
                                           0, 0, &brcm_msg_level);