struct mlx4_en_rx_alloc *ring_alloc,
                              int i)
 {
-       struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_frag_info *frag_info = &priv->frag_info[i];
        struct mlx4_en_rx_alloc *page_alloc = &ring_alloc[i];
        struct page *page;
                skb_frags[i].offset = page_alloc->offset;
                page_alloc->offset += frag_info->frag_stride;
        }
-       dma = pci_map_single(mdev->pdev, page_address(skb_frags[i].page) +
+       dma = dma_map_single(priv->ddev, page_address(skb_frags[i].page) +
                             skb_frags[i].offset, frag_info->frag_size,
                             PCI_DMA_FROMDEVICE);
        rx_desc->data[i].addr = cpu_to_be64(dma);
                                 struct mlx4_en_rx_ring *ring,
                                 int index)
 {
-       struct mlx4_en_dev *mdev = priv->mdev;
        struct page_frag *skb_frags;
        struct mlx4_en_rx_desc *rx_desc = ring->buf + (index << ring->log_stride);
        dma_addr_t dma;
                dma = be64_to_cpu(rx_desc->data[nr].addr);
 
                en_dbg(DRV, priv, "Unmapping buffer at dma:0x%llx\n", (u64) dma);
-               pci_unmap_single(mdev->pdev, dma, skb_frags[nr].size,
+               dma_unmap_single(priv->ddev, dma, skb_frags[nr].size,
                                 PCI_DMA_FROMDEVICE);
                put_page(skb_frags[nr].page);
        }
                                    int length)
 {
        struct skb_frag_struct *skb_frags_rx = skb_shinfo(skb)->frags;
-       struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_frag_info *frag_info;
        int nr;
        dma_addr_t dma;
                        goto fail;
 
                /* Unmap buffer */
-               pci_unmap_single(mdev->pdev, dma, skb_frag_size(&skb_frags_rx[nr]),
+               dma_unmap_single(priv->ddev, dma, skb_frag_size(&skb_frags_rx[nr]),
                                 PCI_DMA_FROMDEVICE);
        }
        /* Adjust size of last fragment to match actual length */
                                      struct mlx4_en_rx_alloc *page_alloc,
                                      unsigned int length)
 {
-       struct mlx4_en_dev *mdev = priv->mdev;
        struct sk_buff *skb;
        void *va;
        int used_frags;
                /* We are copying all relevant data to the skb - temporarily
                 * synch buffers for the copy */
                dma = be64_to_cpu(rx_desc->data[0].addr);
-               dma_sync_single_for_cpu(&mdev->pdev->dev, dma, length,
+               dma_sync_single_for_cpu(priv->ddev, dma, length,
                                        DMA_FROM_DEVICE);
                skb_copy_to_linear_data(skb, va, length);
-               dma_sync_single_for_device(&mdev->pdev->dev, dma, length,
+               dma_sync_single_for_device(priv->ddev, dma, length,
                                           DMA_FROM_DEVICE);
                skb->tail += length;
        } else {
 
                                struct mlx4_en_tx_ring *ring,
                                int index, u8 owner)
 {
-       struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_tx_info *tx_info = &ring->tx_info[index];
        struct mlx4_en_tx_desc *tx_desc = ring->buf + index * TXBB_SIZE;
        struct mlx4_wqe_data_seg *data = (void *) tx_desc + tx_info->data_offset;
        if (likely((void *) tx_desc + tx_info->nr_txbb * TXBB_SIZE <= end)) {
                if (!tx_info->inl) {
                        if (tx_info->linear) {
-                               pci_unmap_single(mdev->pdev,
+                               dma_unmap_single(priv->ddev,
                                        (dma_addr_t) be64_to_cpu(data->addr),
                                         be32_to_cpu(data->byte_count),
                                         PCI_DMA_TODEVICE);
 
                        for (i = 0; i < frags; i++) {
                                frag = &skb_shinfo(skb)->frags[i];
-                               pci_unmap_page(mdev->pdev,
+                               dma_unmap_page(priv->ddev,
                                        (dma_addr_t) be64_to_cpu(data[i].addr),
                                        skb_frag_size(frag), PCI_DMA_TODEVICE);
                        }
                        }
 
                        if (tx_info->linear) {
-                               pci_unmap_single(mdev->pdev,
+                               dma_unmap_single(priv->ddev,
                                        (dma_addr_t) be64_to_cpu(data->addr),
                                         be32_to_cpu(data->byte_count),
                                         PCI_DMA_TODEVICE);
                                if ((void *) data >= end)
                                        data = ring->buf;
                                frag = &skb_shinfo(skb)->frags[i];
-                               pci_unmap_page(mdev->pdev,
+                               dma_unmap_page(priv->ddev,
                                        (dma_addr_t) be64_to_cpu(data->addr),
                                         skb_frag_size(frag), PCI_DMA_TODEVICE);
                                ++data;
                /* Map fragments */
                for (i = skb_shinfo(skb)->nr_frags - 1; i >= 0; i--) {
                        frag = &skb_shinfo(skb)->frags[i];
-                       dma = skb_frag_dma_map(&mdev->dev->pdev->dev, frag,
+                       dma = skb_frag_dma_map(priv->ddev, frag,
                                               0, skb_frag_size(frag),
                                               DMA_TO_DEVICE);
                        data->addr = cpu_to_be64(dma);
 
                /* Map linear part */
                if (tx_info->linear) {
-                       dma = pci_map_single(mdev->dev->pdev, skb->data + lso_header_size,
+                       dma = dma_map_single(priv->ddev, skb->data + lso_header_size,
                                             skb_headlen(skb) - lso_header_size, PCI_DMA_TODEVICE);
                        data->addr = cpu_to_be64(dma);
                        data->lkey = cpu_to_be32(mdev->mr.key);