cross-tree: phase out dma_zalloc_coherent()

We already need to zero out memory for dma_alloc_coherent(), as such
using dma_zalloc_coherent() is superflous. Phase it out.

This change was generated with the following Coccinelle SmPL patch:

@ replace_dma_zalloc_coherent @
expression dev, size, data, handle, flags;
@@

-dma_zalloc_coherent(dev, size, handle, flags)
+dma_alloc_coherent(dev, size, handle, flags)

Suggested-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Luis Chamberlain <mcgrof@kernel.org>
[hch: re-ran the script on the latest tree]
Signed-off-by: Christoph Hellwig <hch@lst.de>

75 files changed, 392 insertions, 419 deletions

diff --git a/drivers/net/ethernet/aeroflex/greth.c b/drivers/net/ethernet/aeroflex/greth.c
index 91fc64c1145e..47e5984f16fb 100644
--- a/drivers/net/ethernet/aeroflex/greth.c
+++ b/drivers/net/ethernet/aeroflex/greth.c
@@ -1433,18 +1433,18 @@ static int greth_of_probe(struct platform_device *ofdev)
         }
 
         /* Allocate TX descriptor ring in coherent memory */
-        greth->tx_bd_base = dma_zalloc_coherent(greth->dev, 1024,
-                                                &greth->tx_bd_base_phys,
-                                                GFP_KERNEL);
+        greth->tx_bd_base = dma_alloc_coherent(greth->dev, 1024,
+                                               &greth->tx_bd_base_phys,
+                                               GFP_KERNEL);
         if (!greth->tx_bd_base) {
                 err = -ENOMEM;
                 goto error3;
         }
 
         /* Allocate RX descriptor ring in coherent memory */
-        greth->rx_bd_base = dma_zalloc_coherent(greth->dev, 1024,
-                                                &greth->rx_bd_base_phys,
-                                                GFP_KERNEL);
+        greth->rx_bd_base = dma_alloc_coherent(greth->dev, 1024,
+                                               &greth->rx_bd_base_phys,
+                                               GFP_KERNEL);
         if (!greth->rx_bd_base) {
                 err = -ENOMEM;
                 goto error4;
diff --git a/drivers/net/ethernet/alacritech/slicoss.c b/drivers/net/ethernet/alacritech/slicoss.c
index 0b60921c392f..16477aa6d61f 100644
--- a/drivers/net/ethernet/alacritech/slicoss.c
+++ b/drivers/net/ethernet/alacritech/slicoss.c
@@ -795,8 +795,8 @@ static int slic_init_stat_queue(struct slic_device *sdev)
         size = stq->len * sizeof(*descs) + DESC_ALIGN_MASK;
 
         for (i = 0; i < SLIC_NUM_STAT_DESC_ARRAYS; i++) {
-                descs = dma_zalloc_coherent(&sdev->pdev->dev, size, &paddr,
-                                            GFP_KERNEL);
+                descs = dma_alloc_coherent(&sdev->pdev->dev, size, &paddr,
+                                           GFP_KERNEL);
                 if (!descs) {
                         netdev_err(sdev->netdev,
                                    "failed to allocate status descriptors\n");
@@ -1240,8 +1240,8 @@ static int slic_init_shmem(struct slic_device *sdev)
         struct slic_shmem_data *sm_data;
         dma_addr_t paddr;
 
-        sm_data = dma_zalloc_coherent(&sdev->pdev->dev, sizeof(*sm_data),
-                                      &paddr, GFP_KERNEL);
+        sm_data = dma_alloc_coherent(&sdev->pdev->dev, sizeof(*sm_data),
+                                     &paddr, GFP_KERNEL);
         if (!sm_data) {
                 dev_err(&sdev->pdev->dev, "failed to allocate shared memory\n");
                 return -ENOMEM;
@@ -1621,8 +1621,8 @@ static int slic_read_eeprom(struct slic_device *sdev)
         int err = 0;
         u8 *mac[2];
 
-        eeprom = dma_zalloc_coherent(&sdev->pdev->dev, SLIC_EEPROM_SIZE,
-                                     &paddr, GFP_KERNEL);
+        eeprom = dma_alloc_coherent(&sdev->pdev->dev, SLIC_EEPROM_SIZE,
+                                    &paddr, GFP_KERNEL);
         if (!eeprom)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
index 420cede41ca4..b17d435de09f 100644
--- a/drivers/net/ethernet/amazon/ena/ena_com.c
+++ b/drivers/net/ethernet/amazon/ena/ena_com.c
@@ -111,8 +111,8 @@ static int ena_com_admin_init_sq(struct ena_com_admin_queue *queue)
         struct ena_com_admin_sq *sq = &queue->sq;
         u16 size = ADMIN_SQ_SIZE(queue->q_depth);
 
-        sq->entries = dma_zalloc_coherent(queue->q_dmadev, size, &sq->dma_addr,
-                                          GFP_KERNEL);
+        sq->entries = dma_alloc_coherent(queue->q_dmadev, size, &sq->dma_addr,
+                                         GFP_KERNEL);
 
         if (!sq->entries) {
                 pr_err("memory allocation failed");
@@ -133,8 +133,8 @@ static int ena_com_admin_init_cq(struct ena_com_admin_queue *queue)
         struct ena_com_admin_cq *cq = &queue->cq;
         u16 size = ADMIN_CQ_SIZE(queue->q_depth);
 
-        cq->entries = dma_zalloc_coherent(queue->q_dmadev, size, &cq->dma_addr,
-                                          GFP_KERNEL);
+        cq->entries = dma_alloc_coherent(queue->q_dmadev, size, &cq->dma_addr,
+                                         GFP_KERNEL);
 
         if (!cq->entries) {
                 pr_err("memory allocation failed");
@@ -156,8 +156,8 @@ static int ena_com_admin_init_aenq(struct ena_com_dev *dev,
 
         dev->aenq.q_depth = ENA_ASYNC_QUEUE_DEPTH;
         size = ADMIN_AENQ_SIZE(ENA_ASYNC_QUEUE_DEPTH);
-        aenq->entries = dma_zalloc_coherent(dev->dmadev, size, &aenq->dma_addr,
-                                            GFP_KERNEL);
+        aenq->entries = dma_alloc_coherent(dev->dmadev, size, &aenq->dma_addr,
+                                           GFP_KERNEL);
 
         if (!aenq->entries) {
                 pr_err("memory allocation failed");
@@ -344,15 +344,15 @@ static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
                 dev_node = dev_to_node(ena_dev->dmadev);
                 set_dev_node(ena_dev->dmadev, ctx->numa_node);
                 io_sq->desc_addr.virt_addr =
-                        dma_zalloc_coherent(ena_dev->dmadev, size,
-                                            &io_sq->desc_addr.phys_addr,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(ena_dev->dmadev, size,
+                                           &io_sq->desc_addr.phys_addr,
+                                           GFP_KERNEL);
                 set_dev_node(ena_dev->dmadev, dev_node);
                 if (!io_sq->desc_addr.virt_addr) {
                         io_sq->desc_addr.virt_addr =
-                                dma_zalloc_coherent(ena_dev->dmadev, size,
-                                                    &io_sq->desc_addr.phys_addr,
-                                                    GFP_KERNEL);
+                                dma_alloc_coherent(ena_dev->dmadev, size,
+                                                   &io_sq->desc_addr.phys_addr,
+                                                   GFP_KERNEL);
                 }
 
                 if (!io_sq->desc_addr.virt_addr) {
@@ -425,14 +425,14 @@ static int ena_com_init_io_cq(struct ena_com_dev *ena_dev,
         prev_node = dev_to_node(ena_dev->dmadev);
         set_dev_node(ena_dev->dmadev, ctx->numa_node);
         io_cq->cdesc_addr.virt_addr =
-                dma_zalloc_coherent(ena_dev->dmadev, size,
-                                    &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, size,
+                                   &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
         set_dev_node(ena_dev->dmadev, prev_node);
         if (!io_cq->cdesc_addr.virt_addr) {
                 io_cq->cdesc_addr.virt_addr =
-                        dma_zalloc_coherent(ena_dev->dmadev, size,
-                                            &io_cq->cdesc_addr.phys_addr,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(ena_dev->dmadev, size,
+                                           &io_cq->cdesc_addr.phys_addr,
+                                           GFP_KERNEL);
         }
 
         if (!io_cq->cdesc_addr.virt_addr) {
@@ -1026,8 +1026,8 @@ static int ena_com_hash_key_allocate(struct ena_com_dev *ena_dev)
         struct ena_rss *rss = &ena_dev->rss;
 
         rss->hash_key =
-                dma_zalloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
-                                    &rss->hash_key_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
+                                   &rss->hash_key_dma_addr, GFP_KERNEL);
 
         if (unlikely(!rss->hash_key))
                 return -ENOMEM;
@@ -1050,8 +1050,8 @@ static int ena_com_hash_ctrl_init(struct ena_com_dev *ena_dev)
         struct ena_rss *rss = &ena_dev->rss;
 
         rss->hash_ctrl =
-                dma_zalloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
-                                    &rss->hash_ctrl_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
+                                   &rss->hash_ctrl_dma_addr, GFP_KERNEL);
 
         if (unlikely(!rss->hash_ctrl))
                 return -ENOMEM;
@@ -1094,8 +1094,8 @@ static int ena_com_indirect_table_allocate(struct ena_com_dev *ena_dev,
                 sizeof(struct ena_admin_rss_ind_table_entry);
 
         rss->rss_ind_tbl =
-                dma_zalloc_coherent(ena_dev->dmadev, tbl_size,
-                                    &rss->rss_ind_tbl_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, tbl_size,
+                                   &rss->rss_ind_tbl_dma_addr, GFP_KERNEL);
         if (unlikely(!rss->rss_ind_tbl))
                 goto mem_err1;
 
@@ -1649,9 +1649,9 @@ int ena_com_mmio_reg_read_request_init(struct ena_com_dev *ena_dev)
 
         spin_lock_init(&mmio_read->lock);
         mmio_read->read_resp =
-                dma_zalloc_coherent(ena_dev->dmadev,
-                                    sizeof(*mmio_read->read_resp),
-                                    &mmio_read->read_resp_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev,
+                                   sizeof(*mmio_read->read_resp),
+                                   &mmio_read->read_resp_dma_addr, GFP_KERNEL);
         if (unlikely(!mmio_read->read_resp))
                 goto err;
 
@@ -2623,8 +2623,8 @@ int ena_com_allocate_host_info(struct ena_com_dev *ena_dev)
         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
 
         host_attr->host_info =
-                dma_zalloc_coherent(ena_dev->dmadev, SZ_4K,
-                                    &host_attr->host_info_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, SZ_4K,
+                                   &host_attr->host_info_dma_addr, GFP_KERNEL);
         if (unlikely(!host_attr->host_info))
                 return -ENOMEM;
 
@@ -2641,8 +2641,9 @@ int ena_com_allocate_debug_area(struct ena_com_dev *ena_dev,
         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
 
         host_attr->debug_area_virt_addr =
-                dma_zalloc_coherent(ena_dev->dmadev, debug_area_size,
-                                    &host_attr->debug_area_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, debug_area_size,
+                                   &host_attr->debug_area_dma_addr,
+                                   GFP_KERNEL);
         if (unlikely(!host_attr->debug_area_virt_addr)) {
                 host_attr->debug_area_size = 0;
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/apm/xgene-v2/main.c b/drivers/net/ethernet/apm/xgene-v2/main.c
index 0f2ad50f3bd7..87b142a312e0 100644
--- a/drivers/net/ethernet/apm/xgene-v2/main.c
+++ b/drivers/net/ethernet/apm/xgene-v2/main.c
@@ -206,8 +206,8 @@ static netdev_tx_t xge_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         }
 
         /* Packet buffers should be 64B aligned */
-        pkt_buf = dma_zalloc_coherent(dev, XGENE_ENET_STD_MTU, &dma_addr,
-                                      GFP_ATOMIC);
+        pkt_buf = dma_alloc_coherent(dev, XGENE_ENET_STD_MTU, &dma_addr,
+                                     GFP_ATOMIC);
         if (unlikely(!pkt_buf)) {
                 dev_kfree_skb_any(skb);
                 return NETDEV_TX_OK;
@@ -428,8 +428,8 @@ static struct xge_desc_ring *xge_create_desc_ring(struct net_device *ndev)
         ring->ndev = ndev;
 
         size = XGENE_ENET_DESC_SIZE * XGENE_ENET_NUM_DESC;
-        ring->desc_addr = dma_zalloc_coherent(dev, size, &ring->dma_addr,
-                                              GFP_KERNEL);
+        ring->desc_addr = dma_alloc_coherent(dev, size, &ring->dma_addr,
+                                             GFP_KERNEL);
         if (!ring->desc_addr)
                 goto err;
 
diff --git a/drivers/net/ethernet/atheros/alx/main.c b/drivers/net/ethernet/atheros/alx/main.c
index c131cfc1b79d..e3538ba7d0e7 100644
--- a/drivers/net/ethernet/atheros/alx/main.c
+++ b/drivers/net/ethernet/atheros/alx/main.c
@@ -660,10 +660,9 @@ static int alx_alloc_rings(struct alx_priv *alx)
                             alx->num_txq +
                             sizeof(struct alx_rrd) * alx->rx_ringsz +
                             sizeof(struct alx_rfd) * alx->rx_ringsz;
-        alx->descmem.virt = dma_zalloc_coherent(&alx->hw.pdev->dev,
-                                                alx->descmem.size,
-                                                &alx->descmem.dma,
-                                                GFP_KERNEL);
+        alx->descmem.virt = dma_alloc_coherent(&alx->hw.pdev->dev,
+                                               alx->descmem.size,
+                                               &alx->descmem.dma, GFP_KERNEL);
         if (!alx->descmem.virt)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
index 7087b88550db..3a3b35b5df67 100644
--- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
+++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
@@ -1019,8 +1019,8 @@ static int atl1c_setup_ring_resources(struct atl1c_adapter *adapter)
                 sizeof(struct atl1c_recv_ret_status) * rx_desc_count +
                 8 * 4;
 
-        ring_header->desc = dma_zalloc_coherent(&pdev->dev, ring_header->size,
-                                                &ring_header->dma, GFP_KERNEL);
+        ring_header->desc = dma_alloc_coherent(&pdev->dev, ring_header->size,
+                                               &ring_header->dma, GFP_KERNEL);
         if (unlikely(!ring_header->desc)) {
                 dev_err(&pdev->dev, "could not get memory for DMA buffer\n");
                 goto err_nomem;
diff --git a/drivers/net/ethernet/broadcom/bcm63xx_enet.c b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
index 6bae973d4dce..09cd188826b1 100644
--- a/drivers/net/ethernet/broadcom/bcm63xx_enet.c
+++ b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
@@ -936,7 +936,7 @@ static int bcm_enet_open(struct net_device *dev)
 
         /* allocate rx dma ring */
         size = priv->rx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
         if (!p) {
                 ret = -ENOMEM;
                 goto out_freeirq_tx;
@@ -947,7 +947,7 @@ static int bcm_enet_open(struct net_device *dev)
 
         /* allocate tx dma ring */
         size = priv->tx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
         if (!p) {
                 ret = -ENOMEM;
                 goto out_free_rx_ring;
@@ -2120,7 +2120,7 @@ static int bcm_enetsw_open(struct net_device *dev)
 
         /* allocate rx dma ring */
         size = priv->rx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
         if (!p) {
                 dev_err(kdev, "cannot allocate rx ring %u\n", size);
                 ret = -ENOMEM;
@@ -2132,7 +2132,7 @@ static int bcm_enetsw_open(struct net_device *dev)
 
         /* allocate tx dma ring */
         size = priv->tx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
         if (!p) {
                 dev_err(kdev, "cannot allocate tx ring\n");
                 ret = -ENOMEM;
diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
index 4574275ef445..f9521d0274b7 100644
--- a/drivers/net/ethernet/broadcom/bcmsysport.c
+++ b/drivers/net/ethernet/broadcom/bcmsysport.c
@@ -1506,8 +1506,8 @@ static int bcm_sysport_init_tx_ring(struct bcm_sysport_priv *priv,
         /* We just need one DMA descriptor which is DMA-able, since writing to
          * the port will allocate a new descriptor in its internal linked-list
          */
-        p = dma_zalloc_coherent(kdev, sizeof(struct dma_desc), &ring->desc_dma,
-                                GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, sizeof(struct dma_desc), &ring->desc_dma,
+                               GFP_KERNEL);
         if (!p) {
                 netif_err(priv, hw, priv->netdev, "DMA alloc failed\n");
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/broadcom/bgmac.c b/drivers/net/ethernet/broadcom/bgmac.c
index cabc8e49ad24..2d3a44c40221 100644
--- a/drivers/net/ethernet/broadcom/bgmac.c
+++ b/drivers/net/ethernet/broadcom/bgmac.c
@@ -634,9 +634,9 @@ static int bgmac_dma_alloc(struct bgmac *bgmac)
 
                 /* Alloc ring of descriptors */
                 size = BGMAC_TX_RING_SLOTS * sizeof(struct bgmac_dma_desc);
-                ring->cpu_base = dma_zalloc_coherent(dma_dev, size,
-                                                     &ring->dma_base,
-                                                     GFP_KERNEL);
+                ring->cpu_base = dma_alloc_coherent(dma_dev, size,
+                                                    &ring->dma_base,
+                                                    GFP_KERNEL);
                 if (!ring->cpu_base) {
                         dev_err(bgmac->dev, "Allocation of TX ring 0x%X failed\n",
                                 ring->mmio_base);
@@ -659,9 +659,9 @@ static int bgmac_dma_alloc(struct bgmac *bgmac)
 
                 /* Alloc ring of descriptors */
                 size = BGMAC_RX_RING_SLOTS * sizeof(struct bgmac_dma_desc);
-                ring->cpu_base = dma_zalloc_coherent(dma_dev, size,
-                                                     &ring->dma_base,
-                                                     GFP_KERNEL);
+                ring->cpu_base = dma_alloc_coherent(dma_dev, size,
+                                                    &ring->dma_base,
+                                                    GFP_KERNEL);
                 if (!ring->cpu_base) {
                         dev_err(bgmac->dev, "Allocation of RX ring 0x%X failed\n",
                                 ring->mmio_base);
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index bbb247116045..d63371d70bce 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -844,8 +844,8 @@ bnx2_alloc_stats_blk(struct net_device *dev)
                                                  BNX2_SBLK_MSIX_ALIGN_SIZE);
         bp->status_stats_size = status_blk_size +
                                 sizeof(struct statistics_block);
-        status_blk = dma_zalloc_coherent(&bp->pdev->dev, bp->status_stats_size,
-                                         &bp->status_blk_mapping, GFP_KERNEL);
+        status_blk = dma_alloc_coherent(&bp->pdev->dev, bp->status_stats_size,
+                                        &bp->status_blk_mapping, GFP_KERNEL);
         if (!status_blk)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index 3aa80da973d7..4ab6eb3baefc 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -3449,10 +3449,10 @@ alloc_ext_stats:
                         goto alloc_tx_ext_stats;
 
                 bp->hw_rx_port_stats_ext =
-                        dma_zalloc_coherent(&pdev->dev,
-                                            sizeof(struct rx_port_stats_ext),
-                                            &bp->hw_rx_port_stats_ext_map,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(&pdev->dev,
+                                           sizeof(struct rx_port_stats_ext),
+                                           &bp->hw_rx_port_stats_ext_map,
+                                           GFP_KERNEL);
                 if (!bp->hw_rx_port_stats_ext)
                         return 0;
 
@@ -3462,10 +3462,10 @@ alloc_tx_ext_stats:
 
                 if (bp->hwrm_spec_code >= 0x10902) {
                         bp->hw_tx_port_stats_ext =
-                                dma_zalloc_coherent(&pdev->dev,
-                                            sizeof(struct tx_port_stats_ext),
-                                            &bp->hw_tx_port_stats_ext_map,
-                                            GFP_KERNEL);
+                                dma_alloc_coherent(&pdev->dev,
+                                                   sizeof(struct tx_port_stats_ext),
+                                                   &bp->hw_tx_port_stats_ext_map,
+                                                   GFP_KERNEL);
                 }
                 bp->flags |= BNXT_FLAG_PORT_STATS_EXT;
         }
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c
index 15c7041e937b..70775158c8c4 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c
@@ -316,8 +316,8 @@ static int bnxt_hwrm_set_dcbx_app(struct bnxt *bp, struct dcb_app *app,
 
         n = IEEE_8021QAZ_MAX_TCS;
         data_len = sizeof(*data) + sizeof(*fw_app) * n;
-        data = dma_zalloc_coherent(&bp->pdev->dev, data_len, &mapping,
-                                   GFP_KERNEL);
+        data = dma_alloc_coherent(&bp->pdev->dev, data_len, &mapping,
+                                  GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c
index 140dbd62106d..7f56032e44ac 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c
@@ -85,8 +85,8 @@ static int bnxt_hwrm_nvm_req(struct bnxt *bp, u32 param_id, void *msg,
                 return -EFAULT;
         }
 
-        data_addr = dma_zalloc_coherent(&bp->pdev->dev, bytesize,
-                                        &data_dma_addr, GFP_KERNEL);
+        data_addr = dma_alloc_coherent(&bp->pdev->dev, bytesize,
+                                       &data_dma_addr, GFP_KERNEL);
         if (!data_addr)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 3b1397af81f7..b1627dd5f2fd 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -8712,10 +8712,10 @@ static int tg3_mem_rx_acquire(struct tg3 *tp)
                 if (!i && tg3_flag(tp, ENABLE_RSS))
                         continue;
 
-                tnapi->rx_rcb = dma_zalloc_coherent(&tp->pdev->dev,
-                                                    TG3_RX_RCB_RING_BYTES(tp),
-                                                    &tnapi->rx_rcb_mapping,
-                                                    GFP_KERNEL);
+                tnapi->rx_rcb = dma_alloc_coherent(&tp->pdev->dev,
+                                                   TG3_RX_RCB_RING_BYTES(tp),
+                                                   &tnapi->rx_rcb_mapping,
+                                                   GFP_KERNEL);
                 if (!tnapi->rx_rcb)
                         goto err_out;
         }
@@ -8768,9 +8768,9 @@ static int tg3_alloc_consistent(struct tg3 *tp)
 {
         int i;
 
-        tp->hw_stats = dma_zalloc_coherent(&tp->pdev->dev,
-                                           sizeof(struct tg3_hw_stats),
-                                           &tp->stats_mapping, GFP_KERNEL);
+        tp->hw_stats = dma_alloc_coherent(&tp->pdev->dev,
+                                          sizeof(struct tg3_hw_stats),
+                                          &tp->stats_mapping, GFP_KERNEL);
         if (!tp->hw_stats)
                 goto err_out;
 
@@ -8778,10 +8778,10 @@ static int tg3_alloc_consistent(struct tg3 *tp)
                 struct tg3_napi *tnapi = &tp->napi[i];
                 struct tg3_hw_status *sblk;
 
-                tnapi->hw_status = dma_zalloc_coherent(&tp->pdev->dev,
-                                                       TG3_HW_STATUS_SIZE,
-                                                       &tnapi->status_mapping,
-                                                       GFP_KERNEL);
+                tnapi->hw_status = dma_alloc_coherent(&tp->pdev->dev,
+                                                      TG3_HW_STATUS_SIZE,
+                                                      &tnapi->status_mapping,
+                                                      GFP_KERNEL);
                 if (!tnapi->hw_status)
                         goto err_out;
 
diff --git a/drivers/net/ethernet/cavium/thunder/nicvf_queues.c b/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
index fcaf18fa3904..5b4d3badcb73 100644
--- a/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
+++ b/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
@@ -59,7 +59,7 @@ static int nicvf_alloc_q_desc_mem(struct nicvf *nic, struct q_desc_mem *dmem,
         dmem->q_len = q_len;
         dmem->size = (desc_size * q_len) + align_bytes;
         /* Save address, need it while freeing */
-        dmem->unalign_base = dma_zalloc_coherent(&nic->pdev->dev, dmem->size,
+        dmem->unalign_base = dma_alloc_coherent(&nic->pdev->dev, dmem->size,
                                                 &dmem->dma, GFP_KERNEL);
         if (!dmem->unalign_base)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/chelsio/cxgb3/sge.c b/drivers/net/ethernet/chelsio/cxgb3/sge.c
index 20b6e1b3f5e3..85f22c286680 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/sge.c
@@ -620,7 +620,7 @@ static void *alloc_ring(struct pci_dev *pdev, size_t nelem, size_t elem_size,
 {
         size_t len = nelem * elem_size;
         void *s = NULL;
-        void *p = dma_zalloc_coherent(&pdev->dev, len, phys, GFP_KERNEL);
+        void *p = dma_alloc_coherent(&pdev->dev, len, phys, GFP_KERNEL);
 
         if (!p)
                 return NULL;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/sge.c b/drivers/net/ethernet/chelsio/cxgb4/sge.c
index b90188401d4a..fc0bc6458e84 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/sge.c
@@ -694,7 +694,7 @@ static void *alloc_ring(struct device *dev, size_t nelem, size_t elem_size,
 {
         size_t len = nelem * elem_size + stat_size;
         void *s = NULL;
-        void *p = dma_zalloc_coherent(dev, len, phys, GFP_KERNEL);
+        void *p = dma_alloc_coherent(dev, len, phys, GFP_KERNEL);
 
         if (!p)
                 return NULL;
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
index 3007e1ac1e61..1d534f0baa69 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
@@ -756,7 +756,7 @@ static void *alloc_ring(struct device *dev, size_t nelem, size_t hwsize,
          * Allocate the hardware ring and PCI DMA bus address space for said.
          */
         size_t hwlen = nelem * hwsize + stat_size;
-        void *hwring = dma_zalloc_coherent(dev, hwlen, busaddrp, GFP_KERNEL);
+        void *hwring = dma_alloc_coherent(dev, hwlen, busaddrp, GFP_KERNEL);
 
         if (!hwring)
                 return NULL;
diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.c b/drivers/net/ethernet/emulex/benet/be_cmds.c
index 1e9d882c04ef..59a7f0b99069 100644
--- a/drivers/net/ethernet/emulex/benet/be_cmds.c
+++ b/drivers/net/ethernet/emulex/benet/be_cmds.c
@@ -1808,9 +1808,9 @@ int be_cmd_get_fat_dump(struct be_adapter *adapter, u32 buf_len, void *buf)
         total_size = buf_len;
 
         get_fat_cmd.size = sizeof(struct be_cmd_req_get_fat) + 60*1024;
-        get_fat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                             get_fat_cmd.size,
-                                             &get_fat_cmd.dma, GFP_ATOMIC);
+        get_fat_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                            get_fat_cmd.size,
+                                            &get_fat_cmd.dma, GFP_ATOMIC);
         if (!get_fat_cmd.va)
                 return -ENOMEM;
 
@@ -2302,8 +2302,8 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,
                 return -EINVAL;
 
         cmd.size = sizeof(struct be_cmd_resp_port_type);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failed\n");
                 return -ENOMEM;
@@ -3066,8 +3066,8 @@ int lancer_fw_download(struct be_adapter *adapter,
 
         flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
                                 + LANCER_FW_DOWNLOAD_CHUNK;
-        flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
-                                           &flash_cmd.dma, GFP_KERNEL);
+        flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
+                                          GFP_KERNEL);
         if (!flash_cmd.va)
                 return -ENOMEM;
 
@@ -3184,8 +3184,8 @@ int be_fw_download(struct be_adapter *adapter, const struct firmware *fw)
         }
 
         flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
-        flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
-                                           GFP_KERNEL);
+        flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
+                                          GFP_KERNEL);
         if (!flash_cmd.va)
                 return -ENOMEM;
 
@@ -3435,8 +3435,8 @@ int be_cmd_get_phy_info(struct be_adapter *adapter)
                 goto err;
         }
         cmd.size = sizeof(struct be_cmd_req_get_phy_info);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
                 status = -ENOMEM;
@@ -3522,9 +3522,9 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter)
 
         memset(&attribs_cmd, 0, sizeof(struct be_dma_mem));
         attribs_cmd.size = sizeof(struct be_cmd_resp_cntl_attribs);
-        attribs_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                             attribs_cmd.size,
-                                             &attribs_cmd.dma, GFP_ATOMIC);
+        attribs_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                            attribs_cmd.size,
+                                            &attribs_cmd.dma, GFP_ATOMIC);
         if (!attribs_cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
                 status = -ENOMEM;
@@ -3699,10 +3699,10 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,
 
         memset(&get_mac_list_cmd, 0, sizeof(struct be_dma_mem));
         get_mac_list_cmd.size = sizeof(struct be_cmd_resp_get_mac_list);
-        get_mac_list_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                                  get_mac_list_cmd.size,
-                                                  &get_mac_list_cmd.dma,
-                                                  GFP_ATOMIC);
+        get_mac_list_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                                 get_mac_list_cmd.size,
+                                                 &get_mac_list_cmd.dma,
+                                                 GFP_ATOMIC);
 
         if (!get_mac_list_cmd.va) {
                 dev_err(&adapter->pdev->dev,
@@ -3829,8 +3829,8 @@ int be_cmd_set_mac_list(struct be_adapter *adapter, u8 *mac_array,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_req_set_mac_list);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_KERNEL);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_KERNEL);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -4035,8 +4035,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_acpi_wol_magic_config_v1);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
                 status = -ENOMEM;
@@ -4089,9 +4089,9 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level)
 
         memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
         extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
-        extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            extfat_cmd.size, &extfat_cmd.dma,
-                                            GFP_ATOMIC);
+        extfat_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           extfat_cmd.size, &extfat_cmd.dma,
+                                           GFP_ATOMIC);
         if (!extfat_cmd.va)
                 return -ENOMEM;
 
@@ -4127,9 +4127,9 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter)
 
         memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
         extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
-        extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            extfat_cmd.size, &extfat_cmd.dma,
-                                            GFP_ATOMIC);
+        extfat_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           extfat_cmd.size, &extfat_cmd.dma,
+                                           GFP_ATOMIC);
 
         if (!extfat_cmd.va) {
                 dev_err(&adapter->pdev->dev, "%s: Memory allocation failure\n",
@@ -4354,8 +4354,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res)
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_get_func_config);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
                 status = -ENOMEM;
@@ -4452,8 +4452,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_get_profile_config);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -4539,8 +4539,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_req_set_profile_config);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/emulex/benet/be_ethtool.c b/drivers/net/ethernet/emulex/benet/be_ethtool.c
index 3f6749fc889f..4c218341c51b 100644
--- a/drivers/net/ethernet/emulex/benet/be_ethtool.c
+++ b/drivers/net/ethernet/emulex/benet/be_ethtool.c
@@ -274,8 +274,8 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,
         int status = 0;
 
         read_cmd.size = LANCER_READ_FILE_CHUNK;
-        read_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, read_cmd.size,
-                                          &read_cmd.dma, GFP_ATOMIC);
+        read_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, read_cmd.size,
+                                         &read_cmd.dma, GFP_ATOMIC);
 
         if (!read_cmd.va) {
                 dev_err(&adapter->pdev->dev,
@@ -815,7 +815,7 @@ static int be_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         }
 
         cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
-        cmd.va = dma_zalloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
+        cmd.va = dma_alloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -851,9 +851,9 @@ static int be_test_ddr_dma(struct be_adapter *adapter)
         };
 
         ddrdma_cmd.size = sizeof(struct be_cmd_req_ddrdma_test);
-        ddrdma_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            ddrdma_cmd.size, &ddrdma_cmd.dma,
-                                            GFP_KERNEL);
+        ddrdma_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           ddrdma_cmd.size, &ddrdma_cmd.dma,
+                                           GFP_KERNEL);
         if (!ddrdma_cmd.va)
                 return -ENOMEM;
 
@@ -1014,9 +1014,9 @@ static int be_read_eeprom(struct net_device *netdev,
 
         memset(&eeprom_cmd, 0, sizeof(struct be_dma_mem));
         eeprom_cmd.size = sizeof(struct be_cmd_req_seeprom_read);
-        eeprom_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            eeprom_cmd.size, &eeprom_cmd.dma,
-                                            GFP_KERNEL);
+        eeprom_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           eeprom_cmd.size, &eeprom_cmd.dma,
+                                           GFP_KERNEL);
 
         if (!eeprom_cmd.va)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index 852f5bfe5f6d..d5026909dec5 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -167,8 +167,8 @@ static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
         q->len = len;
         q->entry_size = entry_size;
         mem->size = len * entry_size;
-        mem->va = dma_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
-                                      GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size,
+                                     &mem->dma, GFP_KERNEL);
         if (!mem->va)
                 return -ENOMEM;
         return 0;
@@ -5766,9 +5766,9 @@ static int be_drv_init(struct be_adapter *adapter)
         int status = 0;
 
         mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
-        mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,
-                                                 &mbox_mem_alloc->dma,
-                                                 GFP_KERNEL);
+        mbox_mem_alloc->va = dma_alloc_coherent(dev, mbox_mem_alloc->size,
+                                                &mbox_mem_alloc->dma,
+                                                GFP_KERNEL);
         if (!mbox_mem_alloc->va)
                 return -ENOMEM;
 
@@ -5777,8 +5777,8 @@ static int be_drv_init(struct be_adapter *adapter)
         mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
 
         rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
-        rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,
-                                            &rx_filter->dma, GFP_KERNEL);
+        rx_filter->va = dma_alloc_coherent(dev, rx_filter->size,
+                                           &rx_filter->dma, GFP_KERNEL);
         if (!rx_filter->va) {
                 status = -ENOMEM;
                 goto free_mbox;
@@ -5792,8 +5792,8 @@ static int be_drv_init(struct be_adapter *adapter)
                 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
         else
                 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2);
-        stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size,
-                                            &stats_cmd->dma, GFP_KERNEL);
+        stats_cmd->va = dma_alloc_coherent(dev, stats_cmd->size,
+                                           &stats_cmd->dma, GFP_KERNEL);
         if (!stats_cmd->va) {
                 status = -ENOMEM;
                 goto free_rx_filter;
diff --git a/drivers/net/ethernet/faraday/ftgmac100.c b/drivers/net/ethernet/faraday/ftgmac100.c
index 4d673225ed3e..3e5e97186fc4 100644
--- a/drivers/net/ethernet/faraday/ftgmac100.c
+++ b/drivers/net/ethernet/faraday/ftgmac100.c
@@ -935,16 +935,14 @@ static int ftgmac100_alloc_rings(struct ftgmac100 *priv)
                 return -ENOMEM;
 
         /* Allocate descriptors */
-        priv->rxdes = dma_zalloc_coherent(priv->dev,
-                                          MAX_RX_QUEUE_ENTRIES *
-                                          sizeof(struct ftgmac100_rxdes),
-                                          &priv->rxdes_dma, GFP_KERNEL);
+        priv->rxdes = dma_alloc_coherent(priv->dev,
+                                         MAX_RX_QUEUE_ENTRIES * sizeof(struct ftgmac100_rxdes),
+                                         &priv->rxdes_dma, GFP_KERNEL);
         if (!priv->rxdes)
                 return -ENOMEM;
-        priv->txdes = dma_zalloc_coherent(priv->dev,
-                                          MAX_TX_QUEUE_ENTRIES *
-                                          sizeof(struct ftgmac100_txdes),
-                                          &priv->txdes_dma, GFP_KERNEL);
+        priv->txdes = dma_alloc_coherent(priv->dev,
+                                         MAX_TX_QUEUE_ENTRIES * sizeof(struct ftgmac100_txdes),
+                                         &priv->txdes_dma, GFP_KERNEL);
         if (!priv->txdes)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/faraday/ftmac100.c b/drivers/net/ethernet/faraday/ftmac100.c
index 084f24daf2b5..2a0e820526dc 100644
--- a/drivers/net/ethernet/faraday/ftmac100.c
+++ b/drivers/net/ethernet/faraday/ftmac100.c
@@ -734,10 +734,9 @@ static int ftmac100_alloc_buffers(struct ftmac100 *priv)
 {
         int i;
 
-        priv->descs = dma_zalloc_coherent(priv->dev,
-                                          sizeof(struct ftmac100_descs),
-                                          &priv->descs_dma_addr,
-                                          GFP_KERNEL);
+        priv->descs = dma_alloc_coherent(priv->dev,
+                                         sizeof(struct ftmac100_descs),
+                                         &priv->descs_dma_addr, GFP_KERNEL);
         if (!priv->descs)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c b/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c
index 471805ea363b..e5d853b7b454 100644
--- a/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c
+++ b/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c
@@ -1006,8 +1006,8 @@ static int hix5hd2_init_hw_desc_queue(struct hix5hd2_priv *priv)
 
         for (i = 0; i < QUEUE_NUMS; i++) {
                 size = priv->pool[i].count * sizeof(struct hix5hd2_desc);
-                virt_addr = dma_zalloc_coherent(dev, size, &phys_addr,
-                                                GFP_KERNEL);
+                virt_addr = dma_alloc_coherent(dev, size, &phys_addr,
+                                               GFP_KERNEL);
                 if (virt_addr == NULL)
                         goto error_free_pool;
 
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
index 07cd58798083..1bf7a5f116a0 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
@@ -2041,9 +2041,8 @@ static int hns3_alloc_desc(struct hns3_enet_ring *ring)
 {
         int size = ring->desc_num * sizeof(ring->desc[0]);
 
-        ring->desc = dma_zalloc_coherent(ring_to_dev(ring), size,
-                                         &ring->desc_dma_addr,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(ring_to_dev(ring), size,
+                                        &ring->desc_dma_addr, GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c
index 8af0cef5609b..e483a6e730e6 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c
@@ -39,9 +39,8 @@ static int hclge_alloc_cmd_desc(struct hclge_cmq_ring *ring)
 {
         int size  = ring->desc_num * sizeof(struct hclge_desc);
 
-        ring->desc = dma_zalloc_coherent(cmq_ring_to_dev(ring),
-                                         size, &ring->desc_dma_addr,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(cmq_ring_to_dev(ring), size,
+                                        &ring->desc_dma_addr, GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c b/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c
index d5765c8cf3a3..4e78e8812a04 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c
@@ -115,9 +115,8 @@ static int hclgevf_alloc_cmd_desc(struct hclgevf_cmq_ring *ring)
 {
         int size = ring->desc_num * sizeof(struct hclgevf_desc);
 
-        ring->desc = dma_zalloc_coherent(cmq_ring_to_dev(ring),
-                                         size, &ring->desc_dma_addr,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(cmq_ring_to_dev(ring), size,
+                                        &ring->desc_dma_addr, GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c
index c40603a183df..b4fefb4c3064 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c
@@ -613,8 +613,8 @@ static int alloc_cmd_buf(struct hinic_api_cmd_chain *chain,
         u8 *cmd_vaddr;
         int err = 0;
 
-        cmd_vaddr = dma_zalloc_coherent(&pdev->dev, API_CMD_BUF_SIZE,
-                                        &cmd_paddr, GFP_KERNEL);
+        cmd_vaddr = dma_alloc_coherent(&pdev->dev, API_CMD_BUF_SIZE,
+                                       &cmd_paddr, GFP_KERNEL);
         if (!cmd_vaddr) {
                 dev_err(&pdev->dev, "Failed to allocate API CMD DMA memory\n");
                 return -ENOMEM;
@@ -663,8 +663,8 @@ static int api_cmd_create_cell(struct hinic_api_cmd_chain *chain,
         dma_addr_t node_paddr;
         int err;
 
-        node = dma_zalloc_coherent(&pdev->dev, chain->cell_size,
-                                   &node_paddr, GFP_KERNEL);
+        node = dma_alloc_coherent(&pdev->dev, chain->cell_size, &node_paddr,
+                                  GFP_KERNEL);
         if (!node) {
                 dev_err(&pdev->dev, "Failed to allocate dma API CMD cell\n");
                 return -ENOMEM;
@@ -821,10 +821,10 @@ static int api_chain_init(struct hinic_api_cmd_chain *chain,
         if (!chain->cell_ctxt)
                 return -ENOMEM;
 
-        chain->wb_status = dma_zalloc_coherent(&pdev->dev,
-                                               sizeof(*chain->wb_status),
-                                               &chain->wb_status_paddr,
-                                               GFP_KERNEL);
+        chain->wb_status = dma_alloc_coherent(&pdev->dev,
+                                              sizeof(*chain->wb_status),
+                                              &chain->wb_status_paddr,
+                                              GFP_KERNEL);
         if (!chain->wb_status) {
                 dev_err(&pdev->dev, "Failed to allocate DMA wb status\n");
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c
index 7cb8b9b94726..683e67515016 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c
@@ -593,10 +593,10 @@ static int alloc_eq_pages(struct hinic_eq *eq)
         }
 
         for (pg = 0; pg < eq->num_pages; pg++) {
-                eq->virt_addr[pg] = dma_zalloc_coherent(&pdev->dev,
-                                                        eq->page_size,
-                                                        &eq->dma_addr[pg],
-                                                        GFP_KERNEL);
+                eq->virt_addr[pg] = dma_alloc_coherent(&pdev->dev,
+                                                       eq->page_size,
+                                                       &eq->dma_addr[pg],
+                                                       GFP_KERNEL);
                 if (!eq->virt_addr[pg]) {
                         err = -ENOMEM;
                         goto err_dma_alloc;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c
index 8e5897669a3a..a322a22d9357 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c
@@ -355,9 +355,9 @@ int hinic_io_create_qps(struct hinic_func_to_io *func_to_io,
                 goto err_sq_db;
         }
 
-        ci_addr_base = dma_zalloc_coherent(&pdev->dev, CI_TABLE_SIZE(num_qps),
-                                           &func_to_io->ci_dma_base,
-                                           GFP_KERNEL);
+        ci_addr_base = dma_alloc_coherent(&pdev->dev, CI_TABLE_SIZE(num_qps),
+                                          &func_to_io->ci_dma_base,
+                                          GFP_KERNEL);
         if (!ci_addr_base) {
                 dev_err(&pdev->dev, "Failed to allocate CI area\n");
                 err = -ENOMEM;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c
index bbf9bdd0ee3e..d62cf509646a 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c
@@ -336,9 +336,9 @@ static int alloc_rq_cqe(struct hinic_rq *rq)
                 goto err_cqe_dma_arr_alloc;
 
         for (i = 0; i < wq->q_depth; i++) {
-                rq->cqe[i] = dma_zalloc_coherent(&pdev->dev,
-                                                 sizeof(*rq->cqe[i]),
-                                                 &rq->cqe_dma[i], GFP_KERNEL);
+                rq->cqe[i] = dma_alloc_coherent(&pdev->dev,
+                                                sizeof(*rq->cqe[i]),
+                                                &rq->cqe_dma[i], GFP_KERNEL);
                 if (!rq->cqe[i])
                         goto err_cqe_alloc;
         }
@@ -415,8 +415,8 @@ int hinic_init_rq(struct hinic_rq *rq, struct hinic_hwif *hwif,
 
         /* HW requirements: Must be at least 32 bit */
         pi_size = ALIGN(sizeof(*rq->pi_virt_addr), sizeof(u32));
-        rq->pi_virt_addr = dma_zalloc_coherent(&pdev->dev, pi_size,
-                                               &rq->pi_dma_addr, GFP_KERNEL);
+        rq->pi_virt_addr = dma_alloc_coherent(&pdev->dev, pi_size,
+                                              &rq->pi_dma_addr, GFP_KERNEL);
         if (!rq->pi_virt_addr) {
                 dev_err(&pdev->dev, "Failed to allocate PI address\n");
                 err = -ENOMEM;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c
index 1dfa7eb05c10..cb66e7024659 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c
@@ -114,8 +114,8 @@ static int queue_alloc_page(struct hinic_hwif *hwif, u64 **vaddr, u64 *paddr,
         struct pci_dev *pdev = hwif->pdev;
         dma_addr_t dma_addr;
 
-        *vaddr = dma_zalloc_coherent(&pdev->dev, page_sz, &dma_addr,
-                                     GFP_KERNEL);
+        *vaddr = dma_alloc_coherent(&pdev->dev, page_sz, &dma_addr,
+                                    GFP_KERNEL);
         if (!*vaddr) {
                 dev_err(&pdev->dev, "Failed to allocate dma for wqs page\n");
                 return -ENOMEM;
@@ -482,8 +482,8 @@ static int alloc_wq_pages(struct hinic_wq *wq, struct hinic_hwif *hwif,
                 u64 *paddr = &wq->block_vaddr[i];
                 dma_addr_t dma_addr;
 
-                *vaddr = dma_zalloc_coherent(&pdev->dev, wq->wq_page_size,
-                                             &dma_addr, GFP_KERNEL);
+                *vaddr = dma_alloc_coherent(&pdev->dev, wq->wq_page_size,
+                                            &dma_addr, GFP_KERNEL);
                 if (!*vaddr) {
                         dev_err(&pdev->dev, "Failed to allocate wq page\n");
                         goto err_alloc_wq_pages;
diff --git a/drivers/net/ethernet/ibm/emac/mal.c b/drivers/net/ethernet/ibm/emac/mal.c
index fff09dcf9e34..787d5aca5278 100644
--- a/drivers/net/ethernet/ibm/emac/mal.c
+++ b/drivers/net/ethernet/ibm/emac/mal.c
@@ -636,8 +636,8 @@ static int mal_probe(struct platform_device *ofdev)
         bd_size = sizeof(struct mal_descriptor) *
                 (NUM_TX_BUFF * mal->num_tx_chans +
                  NUM_RX_BUFF * mal->num_rx_chans);
-        mal->bd_virt = dma_zalloc_coherent(&ofdev->dev, bd_size, &mal->bd_dma,
-                                           GFP_KERNEL);
+        mal->bd_virt = dma_alloc_coherent(&ofdev->dev, bd_size, &mal->bd_dma,
+                                          GFP_KERNEL);
         if (mal->bd_virt == NULL) {
                 err = -ENOMEM;
                 goto fail_unmap;
diff --git a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
index 2569a168334c..a41008523c98 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
@@ -993,8 +993,8 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
 
         txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
         txdr->size = ALIGN(txdr->size, 4096);
-        txdr->desc = dma_zalloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
-                                         GFP_KERNEL);
+        txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
+                                        GFP_KERNEL);
         if (!txdr->desc) {
                 ret_val = 2;
                 goto err_nomem;
@@ -1051,8 +1051,8 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
         }
 
         rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
-        rxdr->desc = dma_zalloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
-                                         GFP_KERNEL);
+        rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
+                                        GFP_KERNEL);
         if (!rxdr->desc) {
                 ret_val = 6;
                 goto err_nomem;
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 308c006cb41d..189f231075c2 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -2305,8 +2305,8 @@ static int e1000_alloc_ring_dma(struct e1000_adapter *adapter,
 {
         struct pci_dev *pdev = adapter->pdev;
 
-        ring->desc = dma_zalloc_coherent(&pdev->dev, ring->size, &ring->dma,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(&pdev->dev, ring->size, &ring->dma,
+                                        GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 4d40878e395a..f52e2c46e6a7 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -109,8 +109,8 @@ int i40e_allocate_dma_mem_d(struct i40e_hw *hw, struct i40e_dma_mem *mem,
         struct i40e_pf *pf = (struct i40e_pf *)hw->back;
 
         mem->size = ALIGN(size, alignment);
-        mem->va = dma_zalloc_coherent(&pf->pdev->dev, mem->size,
-                                      &mem->pa, GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&pf->pdev->dev, mem->size, &mem->pa,
+                                     GFP_KERNEL);
         if (!mem->va)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/intel/ixgb/ixgb_main.c b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
index 1d4d1686909a..e5ac2d3fd816 100644
--- a/drivers/net/ethernet/intel/ixgb/ixgb_main.c
+++ b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
@@ -680,8 +680,8 @@ ixgb_setup_tx_resources(struct ixgb_adapter *adapter)
         txdr->size = txdr->count * sizeof(struct ixgb_tx_desc);
         txdr->size = ALIGN(txdr->size, 4096);
 
-        txdr->desc = dma_zalloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
-                                         GFP_KERNEL);
+        txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
+                                        GFP_KERNEL);
         if (!txdr->desc) {
                 vfree(txdr->buffer_info);
                 return -ENOMEM;
@@ -763,8 +763,8 @@ ixgb_setup_rx_resources(struct ixgb_adapter *adapter)
         rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc);
         rxdr->size = ALIGN(rxdr->size, 4096);
 
-        rxdr->desc = dma_zalloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
-                                         GFP_KERNEL);
+        rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
+                                        GFP_KERNEL);
 
         if (!rxdr->desc) {
                 vfree(rxdr->buffer_info);
diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
index e0875476a780..16066c2d5b3a 100644
--- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
+++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
@@ -2044,9 +2044,9 @@ static int mvpp2_aggr_txq_init(struct platform_device *pdev,
         u32 txq_dma;
 
         /* Allocate memory for TX descriptors */
-        aggr_txq->descs = dma_zalloc_coherent(&pdev->dev,
-                                MVPP2_AGGR_TXQ_SIZE * MVPP2_DESC_ALIGNED_SIZE,
-                                &aggr_txq->descs_dma, GFP_KERNEL);
+        aggr_txq->descs = dma_alloc_coherent(&pdev->dev,
+                                             MVPP2_AGGR_TXQ_SIZE * MVPP2_DESC_ALIGNED_SIZE,
+                                             &aggr_txq->descs_dma, GFP_KERNEL);
         if (!aggr_txq->descs)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/marvell/pxa168_eth.c b/drivers/net/ethernet/marvell/pxa168_eth.c
index 0bd4351b2a49..f8a6d6e3cb7a 100644
--- a/drivers/net/ethernet/marvell/pxa168_eth.c
+++ b/drivers/net/ethernet/marvell/pxa168_eth.c
@@ -557,9 +557,9 @@ static int init_hash_table(struct pxa168_eth_private *pep)
          * table is full.
          */
         if (!pep->htpr) {
-                pep->htpr = dma_zalloc_coherent(pep->dev->dev.parent,
-                                                HASH_ADDR_TABLE_SIZE,
-                                                &pep->htpr_dma, GFP_KERNEL);
+                pep->htpr = dma_alloc_coherent(pep->dev->dev.parent,
+                                               HASH_ADDR_TABLE_SIZE,
+                                               &pep->htpr_dma, GFP_KERNEL);
                 if (!pep->htpr)
                         return -ENOMEM;
         } else {
@@ -1044,9 +1044,9 @@ static int rxq_init(struct net_device *dev)
         pep->rx_desc_count = 0;
         size = pep->rx_ring_size * sizeof(struct rx_desc);
         pep->rx_desc_area_size = size;
-        pep->p_rx_desc_area = dma_zalloc_coherent(pep->dev->dev.parent, size,
-                                                  &pep->rx_desc_dma,
-                                                  GFP_KERNEL);
+        pep->p_rx_desc_area = dma_alloc_coherent(pep->dev->dev.parent, size,
+                                                 &pep->rx_desc_dma,
+                                                 GFP_KERNEL);
         if (!pep->p_rx_desc_area)
                 goto out;
 
@@ -1103,9 +1103,9 @@ static int txq_init(struct net_device *dev)
         pep->tx_desc_count = 0;
         size = pep->tx_ring_size * sizeof(struct tx_desc);
         pep->tx_desc_area_size = size;
-        pep->p_tx_desc_area = dma_zalloc_coherent(pep->dev->dev.parent, size,
-                                                  &pep->tx_desc_dma,
-                                                  GFP_KERNEL);
+        pep->p_tx_desc_area = dma_alloc_coherent(pep->dev->dev.parent, size,
+                                                 &pep->tx_desc_dma,
+                                                 GFP_KERNEL);
         if (!pep->p_tx_desc_area)
                 goto out;
         /* Initialize the next_desc_ptr links in the Tx descriptors ring */
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
index 399f565dd85a..fe9653fa8aea 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
@@ -598,10 +598,10 @@ static int mtk_init_fq_dma(struct mtk_eth *eth)
         dma_addr_t dma_addr;
         int i;
 
-        eth->scratch_ring = dma_zalloc_coherent(eth->dev,
-                                                cnt * sizeof(struct mtk_tx_dma),
-                                                &eth->phy_scratch_ring,
-                                                GFP_ATOMIC);
+        eth->scratch_ring = dma_alloc_coherent(eth->dev,
+                                               cnt * sizeof(struct mtk_tx_dma),
+                                               &eth->phy_scratch_ring,
+                                               GFP_ATOMIC);
         if (unlikely(!eth->scratch_ring))
                 return -ENOMEM;
 
@@ -1213,8 +1213,8 @@ static int mtk_tx_alloc(struct mtk_eth *eth)
         if (!ring->buf)
                 goto no_tx_mem;
 
-        ring->dma = dma_zalloc_coherent(eth->dev, MTK_DMA_SIZE * sz,
-                                        &ring->phys, GFP_ATOMIC);
+        ring->dma = dma_alloc_coherent(eth->dev, MTK_DMA_SIZE * sz,
+                                       &ring->phys, GFP_ATOMIC);
         if (!ring->dma)
                 goto no_tx_mem;
 
@@ -1310,9 +1310,9 @@ static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
                         return -ENOMEM;
         }
 
-        ring->dma = dma_zalloc_coherent(eth->dev,
-                                        rx_dma_size * sizeof(*ring->dma),
-                                        &ring->phys, GFP_ATOMIC);
+        ring->dma = dma_alloc_coherent(eth->dev,
+                                       rx_dma_size * sizeof(*ring->dma),
+                                       &ring->phys, GFP_ATOMIC);
         if (!ring->dma)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/alloc.c b/drivers/net/ethernet/mellanox/mlx4/alloc.c
index 9af34e03892c..dbc483e4a2ef 100644
--- a/drivers/net/ethernet/mellanox/mlx4/alloc.c
+++ b/drivers/net/ethernet/mellanox/mlx4/alloc.c
@@ -584,8 +584,8 @@ static int mlx4_buf_direct_alloc(struct mlx4_dev *dev, int size,
         buf->npages       = 1;
         buf->page_shift   = get_order(size) + PAGE_SHIFT;
         buf->direct.buf   =
-                dma_zalloc_coherent(&dev->persist->pdev->dev,
-                                    size, &t, GFP_KERNEL);
+                dma_alloc_coherent(&dev->persist->pdev->dev, size, &t,
+                                   GFP_KERNEL);
         if (!buf->direct.buf)
                 return -ENOMEM;
 
@@ -624,8 +624,8 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
 
                 for (i = 0; i < buf->nbufs; ++i) {
                         buf->page_list[i].buf =
-                                dma_zalloc_coherent(&dev->persist->pdev->dev,
-                                                    PAGE_SIZE, &t, GFP_KERNEL);
+                                dma_alloc_coherent(&dev->persist->pdev->dev,
+                                                   PAGE_SIZE, &t, GFP_KERNEL);
                         if (!buf->page_list[i].buf)
                                 goto err_free;
 
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/alloc.c b/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
index 456f30007ad6..421b9c3c8bf7 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
@@ -63,8 +63,8 @@ static void *mlx5_dma_zalloc_coherent_node(struct mlx5_core_dev *dev,
         mutex_lock(&priv->alloc_mutex);
         original_node = dev_to_node(&dev->pdev->dev);
         set_dev_node(&dev->pdev->dev, node);
-        cpu_handle = dma_zalloc_coherent(&dev->pdev->dev, size,
-                                         dma_handle, GFP_KERNEL);
+        cpu_handle = dma_alloc_coherent(&dev->pdev->dev, size, dma_handle,
+                                        GFP_KERNEL);
         set_dev_node(&dev->pdev->dev, original_node);
         mutex_unlock(&priv->alloc_mutex);
         return cpu_handle;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
index d3125cdf69db..3e0fa8a8077b 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
@@ -1789,8 +1789,8 @@ static int alloc_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd)
 {
         struct device *ddev = &dev->pdev->dev;
 
-        cmd->cmd_alloc_buf = dma_zalloc_coherent(ddev, MLX5_ADAPTER_PAGE_SIZE,
-                                                 &cmd->alloc_dma, GFP_KERNEL);
+        cmd->cmd_alloc_buf = dma_alloc_coherent(ddev, MLX5_ADAPTER_PAGE_SIZE,
+                                                &cmd->alloc_dma, GFP_KERNEL);
         if (!cmd->cmd_alloc_buf)
                 return -ENOMEM;
 
@@ -1804,9 +1804,9 @@ static int alloc_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd)
 
         dma_free_coherent(ddev, MLX5_ADAPTER_PAGE_SIZE, cmd->cmd_alloc_buf,
                           cmd->alloc_dma);
-        cmd->cmd_alloc_buf = dma_zalloc_coherent(ddev,
-                                                 2 * MLX5_ADAPTER_PAGE_SIZE - 1,
-                                                 &cmd->alloc_dma, GFP_KERNEL);
+        cmd->cmd_alloc_buf = dma_alloc_coherent(ddev,
+                                                2 * MLX5_ADAPTER_PAGE_SIZE - 1,
+                                                &cmd->alloc_dma, GFP_KERNEL);
         if (!cmd->cmd_alloc_buf)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
index 5f384f73007d..19ce0e605096 100644
--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
+++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
@@ -3604,9 +3604,9 @@ static int myri10ge_alloc_slices(struct myri10ge_priv *mgp)
         for (i = 0; i < mgp->num_slices; i++) {
                 ss = &mgp->ss[i];
                 bytes = mgp->max_intr_slots * sizeof(*ss->rx_done.entry);
-                ss->rx_done.entry = dma_zalloc_coherent(&pdev->dev, bytes,
-                                                        &ss->rx_done.bus,
-                                                        GFP_KERNEL);
+                ss->rx_done.entry = dma_alloc_coherent(&pdev->dev, bytes,
+                                                       &ss->rx_done.bus,
+                                                       GFP_KERNEL);
                 if (ss->rx_done.entry == NULL)
                         goto abort;
                 bytes = sizeof(*ss->fw_stats);
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
index e97636d2e6ee..7d2d4241498f 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
@@ -2170,9 +2170,9 @@ nfp_net_tx_ring_alloc(struct nfp_net_dp *dp, struct nfp_net_tx_ring *tx_ring)
         tx_ring->cnt = dp->txd_cnt;
 
         tx_ring->size = array_size(tx_ring->cnt, sizeof(*tx_ring->txds));
-        tx_ring->txds = dma_zalloc_coherent(dp->dev, tx_ring->size,
-                                            &tx_ring->dma,
-                                            GFP_KERNEL | __GFP_NOWARN);
+        tx_ring->txds = dma_alloc_coherent(dp->dev, tx_ring->size,
+                                           &tx_ring->dma,
+                                           GFP_KERNEL | __GFP_NOWARN);
         if (!tx_ring->txds) {
                 netdev_warn(dp->netdev, "failed to allocate TX descriptor ring memory, requested descriptor count: %d, consider lowering descriptor count\n",
                             tx_ring->cnt);
@@ -2328,9 +2328,9 @@ nfp_net_rx_ring_alloc(struct nfp_net_dp *dp, struct nfp_net_rx_ring *rx_ring)
 
         rx_ring->cnt = dp->rxd_cnt;
         rx_ring->size = array_size(rx_ring->cnt, sizeof(*rx_ring->rxds));
-        rx_ring->rxds = dma_zalloc_coherent(dp->dev, rx_ring->size,
-                                            &rx_ring->dma,
-                                            GFP_KERNEL | __GFP_NOWARN);
+        rx_ring->rxds = dma_alloc_coherent(dp->dev, rx_ring->size,
+                                           &rx_ring->dma,
+                                           GFP_KERNEL | __GFP_NOWARN);
         if (!rx_ring->rxds) {
                 netdev_warn(dp->netdev, "failed to allocate RX descriptor ring memory, requested descriptor count: %d, consider lowering descriptor count\n",
                             rx_ring->cnt);
diff --git a/drivers/net/ethernet/ni/nixge.c b/drivers/net/ethernet/ni/nixge.c
index 0611f2335b4a..1e408d1a9b5f 100644
--- a/drivers/net/ethernet/ni/nixge.c
+++ b/drivers/net/ethernet/ni/nixge.c
@@ -287,9 +287,9 @@ static int nixge_hw_dma_bd_init(struct net_device *ndev)
         priv->rx_bd_ci = 0;
 
         /* Allocate the Tx and Rx buffer descriptors. */
-        priv->tx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                            sizeof(*priv->tx_bd_v) * TX_BD_NUM,
-                                            &priv->tx_bd_p, GFP_KERNEL);
+        priv->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                           sizeof(*priv->tx_bd_v) * TX_BD_NUM,
+                                           &priv->tx_bd_p, GFP_KERNEL);
         if (!priv->tx_bd_v)
                 goto out;
 
@@ -299,9 +299,9 @@ static int nixge_hw_dma_bd_init(struct net_device *ndev)
         if (!priv->tx_skb)
                 goto out;
 
-        priv->rx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                            sizeof(*priv->rx_bd_v) * RX_BD_NUM,
-                                            &priv->rx_bd_p, GFP_KERNEL);
+        priv->rx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                           sizeof(*priv->rx_bd_v) * RX_BD_NUM,
+                                           &priv->rx_bd_p, GFP_KERNEL);
         if (!priv->rx_bd_v)
                 goto out;
 
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
index 43c0c10dfeb7..552d930e3940 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
@@ -1440,8 +1440,8 @@ pch_gbe_alloc_rx_buffers_pool(struct pch_gbe_adapter *adapter,
 
         size = rx_ring->count * bufsz + PCH_GBE_RESERVE_MEMORY;
         rx_ring->rx_buff_pool =
-                dma_zalloc_coherent(&pdev->dev, size,
-                                    &rx_ring->rx_buff_pool_logic, GFP_KERNEL);
+                dma_alloc_coherent(&pdev->dev, size,
+                                   &rx_ring->rx_buff_pool_logic, GFP_KERNEL);
         if (!rx_ring->rx_buff_pool)
                 return -ENOMEM;
 
@@ -1755,8 +1755,8 @@ int pch_gbe_setup_tx_resources(struct pch_gbe_adapter *adapter,
 
         tx_ring->size = tx_ring->count * (int)sizeof(struct pch_gbe_tx_desc);
 
-        tx_ring->desc = dma_zalloc_coherent(&pdev->dev, tx_ring->size,
-                                            &tx_ring->dma, GFP_KERNEL);
+        tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size,
+                                           &tx_ring->dma, GFP_KERNEL);
         if (!tx_ring->desc) {
                 vfree(tx_ring->buffer_info);
                 return -ENOMEM;
@@ -1798,8 +1798,8 @@ int pch_gbe_setup_rx_resources(struct pch_gbe_adapter *adapter,
                 return -ENOMEM;
 
         rx_ring->size = rx_ring->count * (int)sizeof(struct pch_gbe_rx_desc);
-        rx_ring->desc = dma_zalloc_coherent(&pdev->dev, rx_ring->size,
-                                            &rx_ring->dma, GFP_KERNEL);
+        rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,
+                                                  &rx_ring->dma, GFP_KERNEL);
         if (!rx_ring->desc) {
                 vfree(rx_ring->buffer_info);
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/pasemi/pasemi_mac.c b/drivers/net/ethernet/pasemi/pasemi_mac.c
index 8a31a02c9f47..d21041554507 100644
--- a/drivers/net/ethernet/pasemi/pasemi_mac.c
+++ b/drivers/net/ethernet/pasemi/pasemi_mac.c
@@ -401,9 +401,9 @@ static int pasemi_mac_setup_rx_resources(const struct net_device *dev)
         if (pasemi_dma_alloc_ring(&ring->chan, RX_RING_SIZE))
                 goto out_ring_desc;
 
-        ring->buffers = dma_zalloc_coherent(&mac->dma_pdev->dev,
-                                            RX_RING_SIZE * sizeof(u64),
-                                            &ring->buf_dma, GFP_KERNEL);
+        ring->buffers = dma_alloc_coherent(&mac->dma_pdev->dev,
+                                           RX_RING_SIZE * sizeof(u64),
+                                           &ring->buf_dma, GFP_KERNEL);
         if (!ring->buffers)
                 goto out_ring_desc;
 
diff --git a/drivers/net/ethernet/qlogic/qed/qed_cxt.c b/drivers/net/ethernet/qlogic/qed/qed_cxt.c
index dc1c1b616084..c2ad405b2f50 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_cxt.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_cxt.c
@@ -936,9 +936,9 @@ static int qed_cxt_src_t2_alloc(struct qed_hwfn *p_hwfn)
                 u32 size = min_t(u32, total_size, psz);
                 void **p_virt = &p_mngr->t2[i].p_virt;
 
-                *p_virt = dma_zalloc_coherent(&p_hwfn->cdev->pdev->dev,
-                                              size, &p_mngr->t2[i].p_phys,
-                                              GFP_KERNEL);
+                *p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, size,
+                                             &p_mngr->t2[i].p_phys,
+                                             GFP_KERNEL);
                 if (!p_mngr->t2[i].p_virt) {
                         rc = -ENOMEM;
                         goto t2_fail;
@@ -1054,8 +1054,8 @@ static int qed_ilt_blk_alloc(struct qed_hwfn *p_hwfn,
                 u32 size;
 
                 size = min_t(u32, sz_left, p_blk->real_size_in_page);
-                p_virt = dma_zalloc_coherent(&p_hwfn->cdev->pdev->dev, size,
-                                             &p_phys, GFP_KERNEL);
+                p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, size,
+                                            &p_phys, GFP_KERNEL);
                 if (!p_virt)
                         return -ENOMEM;
 
@@ -2306,9 +2306,9 @@ qed_cxt_dynamic_ilt_alloc(struct qed_hwfn *p_hwfn,
                 goto out0;
         }
 
-        p_virt = dma_zalloc_coherent(&p_hwfn->cdev->pdev->dev,
-                                     p_blk->real_size_in_page, &p_phys,
-                                     GFP_KERNEL);
+        p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev,
+                                    p_blk->real_size_in_page, &p_phys,
+                                    GFP_KERNEL);
         if (!p_virt) {
                 rc = -ENOMEM;
                 goto out1;
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
index d344e9d43832..af38d3d73291 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
@@ -434,14 +434,14 @@ int qlcnic_82xx_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter,
         *(tx_ring->hw_consumer) = 0;
 
         rq_size = SIZEOF_HOSTRQ_TX(struct qlcnic_hostrq_tx_ctx);
-        rq_addr = dma_zalloc_coherent(&adapter->pdev->dev, rq_size,
-                                      &rq_phys_addr, GFP_KERNEL);
+        rq_addr = dma_alloc_coherent(&adapter->pdev->dev, rq_size,
+                                     &rq_phys_addr, GFP_KERNEL);
         if (!rq_addr)
                 return -ENOMEM;
 
         rsp_size = SIZEOF_CARDRSP_TX(struct qlcnic_cardrsp_tx_ctx);
-        rsp_addr = dma_zalloc_coherent(&adapter->pdev->dev, rsp_size,
-                                       &rsp_phys_addr, GFP_KERNEL);
+        rsp_addr = dma_alloc_coherent(&adapter->pdev->dev, rsp_size,
+                                      &rsp_phys_addr, GFP_KERNEL);
         if (!rsp_addr) {
                 err = -ENOMEM;
                 goto out_free_rq;
@@ -855,8 +855,8 @@ int qlcnic_82xx_get_nic_info(struct qlcnic_adapter *adapter,
         struct qlcnic_cmd_args cmd;
         size_t  nic_size = sizeof(struct qlcnic_info_le);
 
-        nic_info_addr = dma_zalloc_coherent(&adapter->pdev->dev, nic_size,
-                                            &nic_dma_t, GFP_KERNEL);
+        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
+                                           &nic_dma_t, GFP_KERNEL);
         if (!nic_info_addr)
                 return -ENOMEM;
 
@@ -909,8 +909,8 @@ int qlcnic_82xx_set_nic_info(struct qlcnic_adapter *adapter,
         if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
                 return err;
 
-        nic_info_addr = dma_zalloc_coherent(&adapter->pdev->dev, nic_size,
-                                            &nic_dma_t, GFP_KERNEL);
+        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
+                                           &nic_dma_t, GFP_KERNEL);
         if (!nic_info_addr)
                 return -ENOMEM;
 
@@ -964,8 +964,8 @@ int qlcnic_82xx_get_pci_info(struct qlcnic_adapter *adapter,
         void *pci_info_addr;
         int err = 0, i;
 
-        pci_info_addr = dma_zalloc_coherent(&adapter->pdev->dev, pci_size,
-                                            &pci_info_dma_t, GFP_KERNEL);
+        pci_info_addr = dma_alloc_coherent(&adapter->pdev->dev, pci_size,
+                                           &pci_info_dma_t, GFP_KERNEL);
         if (!pci_info_addr)
                 return -ENOMEM;
 
@@ -1078,8 +1078,8 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func,
                 return -EIO;
         }
 
-        stats_addr = dma_zalloc_coherent(&adapter->pdev->dev, stats_size,
-                                         &stats_dma_t, GFP_KERNEL);
+        stats_addr = dma_alloc_coherent(&adapter->pdev->dev, stats_size,
+                                        &stats_dma_t, GFP_KERNEL);
         if (!stats_addr)
                 return -ENOMEM;
 
@@ -1134,8 +1134,8 @@ int qlcnic_get_mac_stats(struct qlcnic_adapter *adapter,
         if (mac_stats == NULL)
                 return -ENOMEM;
 
-        stats_addr = dma_zalloc_coherent(&adapter->pdev->dev, stats_size,
-                                         &stats_dma_t, GFP_KERNEL);
+        stats_addr = dma_alloc_coherent(&adapter->pdev->dev, stats_size,
+                                        &stats_dma_t, GFP_KERNEL);
         if (!stats_addr)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/qualcomm/emac/emac-mac.c b/drivers/net/ethernet/qualcomm/emac/emac-mac.c
index 031f6e6ee9c1..8d790313ee3d 100644
--- a/drivers/net/ethernet/qualcomm/emac/emac-mac.c
+++ b/drivers/net/ethernet/qualcomm/emac/emac-mac.c
@@ -776,7 +776,7 @@ int emac_mac_rx_tx_rings_alloc_all(struct emac_adapter *adpt)
                             8 + 2 * 8; /* 8 byte per one Tx and two Rx rings */
 
         ring_header->used = 0;
-        ring_header->v_addr = dma_zalloc_coherent(dev, ring_header->size,
+        ring_header->v_addr = dma_alloc_coherent(dev, ring_header->size,
                                                  &ring_header->dma_addr,
                                                  GFP_KERNEL);
         if (!ring_header->v_addr)
diff --git a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
index 690aee88f0eb..6d22dd500790 100644
--- a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
+++ b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
@@ -400,9 +400,9 @@ static int init_tx_ring(struct device *dev, u8 queue_no,
         }
 
         /* allocate memory for TX descriptors */
-        tx_ring->dma_tx = dma_zalloc_coherent(dev,
-                                              tx_rsize * sizeof(struct sxgbe_tx_norm_desc),
-                                              &tx_ring->dma_tx_phy, GFP_KERNEL);
+        tx_ring->dma_tx = dma_alloc_coherent(dev,
+                                             tx_rsize * sizeof(struct sxgbe_tx_norm_desc),
+                                             &tx_ring->dma_tx_phy, GFP_KERNEL);
         if (!tx_ring->dma_tx)
                 return -ENOMEM;
 
@@ -479,9 +479,9 @@ static int init_rx_ring(struct net_device *dev, u8 queue_no,
         rx_ring->queue_no = queue_no;
 
         /* allocate memory for RX descriptors */
-        rx_ring->dma_rx = dma_zalloc_coherent(priv->device,
-                                              rx_rsize * sizeof(struct sxgbe_rx_norm_desc),
-                                              &rx_ring->dma_rx_phy, GFP_KERNEL);
+        rx_ring->dma_rx = dma_alloc_coherent(priv->device,
+                                             rx_rsize * sizeof(struct sxgbe_rx_norm_desc),
+                                             &rx_ring->dma_rx_phy, GFP_KERNEL);
 
         if (rx_ring->dma_rx == NULL)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/sfc/falcon/nic.c b/drivers/net/ethernet/sfc/falcon/nic.c
index a8ecb33390da..9c07b5175581 100644
--- a/drivers/net/ethernet/sfc/falcon/nic.c
+++ b/drivers/net/ethernet/sfc/falcon/nic.c
@@ -33,8 +33,8 @@
 int ef4_nic_alloc_buffer(struct ef4_nic *efx, struct ef4_buffer *buffer,
                          unsigned int len, gfp_t gfp_flags)
 {
-        buffer->addr = dma_zalloc_coherent(&efx->pci_dev->dev, len,
-                                           &buffer->dma_addr, gfp_flags);
+        buffer->addr = dma_alloc_coherent(&efx->pci_dev->dev, len,
+                                          &buffer->dma_addr, gfp_flags);
         if (!buffer->addr)
                 return -ENOMEM;
         buffer->len = len;
diff --git a/drivers/net/ethernet/sfc/nic.c b/drivers/net/ethernet/sfc/nic.c
index aa1945a858d5..c2d45a40eb48 100644
--- a/drivers/net/ethernet/sfc/nic.c
+++ b/drivers/net/ethernet/sfc/nic.c
@@ -34,8 +34,8 @@
 int efx_nic_alloc_buffer(struct efx_nic *efx, struct efx_buffer *buffer,
                          unsigned int len, gfp_t gfp_flags)
 {
-        buffer->addr = dma_zalloc_coherent(&efx->pci_dev->dev, len,
-                                           &buffer->dma_addr, gfp_flags);
+        buffer->addr = dma_alloc_coherent(&efx->pci_dev->dev, len,
+                                          &buffer->dma_addr, gfp_flags);
         if (!buffer->addr)
                 return -ENOMEM;
         buffer->len = len;
diff --git a/drivers/net/ethernet/sgi/meth.c b/drivers/net/ethernet/sgi/meth.c
index 703fbbefea44..0e1b7e960b98 100644
--- a/drivers/net/ethernet/sgi/meth.c
+++ b/drivers/net/ethernet/sgi/meth.c
@@ -211,8 +211,8 @@ static void meth_check_link(struct net_device *dev)
 static int meth_init_tx_ring(struct meth_private *priv)
 {
         /* Init TX ring */
-        priv->tx_ring = dma_zalloc_coherent(NULL, TX_RING_BUFFER_SIZE,
-                                            &priv->tx_ring_dma, GFP_ATOMIC);
+        priv->tx_ring = dma_alloc_coherent(NULL, TX_RING_BUFFER_SIZE,
+                                           &priv->tx_ring_dma, GFP_ATOMIC);
         if (!priv->tx_ring)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/socionext/netsec.c b/drivers/net/ethernet/socionext/netsec.c
index 05a0948ad929..a18149720aa2 100644
--- a/drivers/net/ethernet/socionext/netsec.c
+++ b/drivers/net/ethernet/socionext/netsec.c
@@ -1029,8 +1029,8 @@ static int netsec_alloc_dring(struct netsec_priv *priv, enum ring_id id)
         struct netsec_desc_ring *dring = &priv->desc_ring[id];
         int i;
 
-        dring->vaddr = dma_zalloc_coherent(priv->dev, DESC_SZ * DESC_NUM,
-                                           &dring->desc_dma, GFP_KERNEL);
+        dring->vaddr = dma_alloc_coherent(priv->dev, DESC_SZ * DESC_NUM,
+                                          &dring->desc_dma, GFP_KERNEL);
         if (!dring->vaddr)
                 goto err;
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 0e0a0789c2ed..0c4ab3444cc3 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -1549,22 +1549,18 @@ static int alloc_dma_rx_desc_resources(struct stmmac_priv *priv)
                         goto err_dma;
 
                 if (priv->extend_desc) {
-                        rx_q->dma_erx = dma_zalloc_coherent(priv->device,
-                                                            DMA_RX_SIZE *
-                                                            sizeof(struct
-                                                            dma_extended_desc),
-                                                            &rx_q->dma_rx_phy,
-                                                            GFP_KERNEL);
+                        rx_q->dma_erx = dma_alloc_coherent(priv->device,
+                                                           DMA_RX_SIZE * sizeof(struct dma_extended_desc),
+                                                           &rx_q->dma_rx_phy,
+                                                           GFP_KERNEL);
                         if (!rx_q->dma_erx)
                                 goto err_dma;
 
                 } else {
-                        rx_q->dma_rx = dma_zalloc_coherent(priv->device,
-                                                           DMA_RX_SIZE *
-                                                           sizeof(struct
-                                                           dma_desc),
-                                                           &rx_q->dma_rx_phy,
-                                                           GFP_KERNEL);
+                        rx_q->dma_rx = dma_alloc_coherent(priv->device,
+                                                          DMA_RX_SIZE * sizeof(struct dma_desc),
+                                                          &rx_q->dma_rx_phy,
+                                                          GFP_KERNEL);
                         if (!rx_q->dma_rx)
                                 goto err_dma;
                 }
@@ -1612,21 +1608,17 @@ static int alloc_dma_tx_desc_resources(struct stmmac_priv *priv)
                         goto err_dma;
 
                 if (priv->extend_desc) {
-                        tx_q->dma_etx = dma_zalloc_coherent(priv->device,
-                                                            DMA_TX_SIZE *
-                                                            sizeof(struct
-                                                            dma_extended_desc),
-                                                            &tx_q->dma_tx_phy,
-                                                            GFP_KERNEL);
+                        tx_q->dma_etx = dma_alloc_coherent(priv->device,
+                                                           DMA_TX_SIZE * sizeof(struct dma_extended_desc),
+                                                           &tx_q->dma_tx_phy,
+                                                           GFP_KERNEL);
                         if (!tx_q->dma_etx)
                                 goto err_dma;
                 } else {
-                        tx_q->dma_tx = dma_zalloc_coherent(priv->device,
-                                                           DMA_TX_SIZE *
-                                                           sizeof(struct
-                                                                  dma_desc),
-                                                           &tx_q->dma_tx_phy,
-                                                           GFP_KERNEL);
+                        tx_q->dma_tx = dma_alloc_coherent(priv->device,
+                                                          DMA_TX_SIZE * sizeof(struct dma_desc),
+                                                          &tx_q->dma_tx_phy,
+                                                          GFP_KERNEL);
                         if (!tx_q->dma_tx)
                                 goto err_dma;
                 }
diff --git a/drivers/net/ethernet/tundra/tsi108_eth.c b/drivers/net/ethernet/tundra/tsi108_eth.c
index edcd1e60b30d..37925a1d58de 100644
--- a/drivers/net/ethernet/tundra/tsi108_eth.c
+++ b/drivers/net/ethernet/tundra/tsi108_eth.c
@@ -1311,13 +1311,13 @@ static int tsi108_open(struct net_device *dev)
                        data->id, dev->irq, dev->name);
         }
 
-        data->rxring = dma_zalloc_coherent(&data->pdev->dev, rxring_size,
-                        &data->rxdma, GFP_KERNEL);
+        data->rxring = dma_alloc_coherent(&data->pdev->dev, rxring_size,
+                                          &data->rxdma, GFP_KERNEL);
         if (!data->rxring)
                 return -ENOMEM;
 
-        data->txring = dma_zalloc_coherent(&data->pdev->dev, txring_size,
-                        &data->txdma, GFP_KERNEL);
+        data->txring = dma_alloc_coherent(&data->pdev->dev, txring_size,
+                                          &data->txdma, GFP_KERNEL);
         if (!data->txring) {
                 dma_free_coherent(&data->pdev->dev, rxring_size, data->rxring,
                                     data->rxdma);
diff --git a/drivers/net/ethernet/xilinx/ll_temac_main.c b/drivers/net/ethernet/xilinx/ll_temac_main.c
index 2241f9897092..15bb058db392 100644
--- a/drivers/net/ethernet/xilinx/ll_temac_main.c
+++ b/drivers/net/ethernet/xilinx/ll_temac_main.c
@@ -243,15 +243,15 @@ static int temac_dma_bd_init(struct net_device *ndev)
 
         /* allocate the tx and rx ring buffer descriptors. */
         /* returns a virtual address and a physical address. */
-        lp->tx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->tx_bd_v) * TX_BD_NUM,
-                                          &lp->tx_bd_p, GFP_KERNEL);
+        lp->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->tx_bd_v) * TX_BD_NUM,
+                                         &lp->tx_bd_p, GFP_KERNEL);
         if (!lp->tx_bd_v)
                 goto out;
 
-        lp->rx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->rx_bd_v) * RX_BD_NUM,
-                                          &lp->rx_bd_p, GFP_KERNEL);
+        lp->rx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->rx_bd_v) * RX_BD_NUM,
+                                         &lp->rx_bd_p, GFP_KERNEL);
         if (!lp->rx_bd_v)
                 goto out;
 
diff --git a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
index 12a14609ec47..0789d8af7d72 100644
--- a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
+++ b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
@@ -199,15 +199,15 @@ static int axienet_dma_bd_init(struct net_device *ndev)
         lp->rx_bd_ci = 0;
 
         /* Allocate the Tx and Rx buffer descriptors. */
-        lp->tx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->tx_bd_v) * TX_BD_NUM,
-                                          &lp->tx_bd_p, GFP_KERNEL);
+        lp->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->tx_bd_v) * TX_BD_NUM,
+                                         &lp->tx_bd_p, GFP_KERNEL);
         if (!lp->tx_bd_v)
                 goto out;
 
-        lp->rx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->rx_bd_v) * RX_BD_NUM,
-                                          &lp->rx_bd_p, GFP_KERNEL);
+        lp->rx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->rx_bd_v) * RX_BD_NUM,
+                                         &lp->rx_bd_p, GFP_KERNEL);
         if (!lp->rx_bd_v)
                 goto out;
 
diff --git a/drivers/net/fddi/defxx.c b/drivers/net/fddi/defxx.c
index 61fceee73c1b..38ac8ef41f5f 100644
--- a/drivers/net/fddi/defxx.c
+++ b/drivers/net/fddi/defxx.c
@@ -1139,9 +1139,9 @@ static int dfx_driver_init(struct net_device *dev, const char *print_name,
 #endif
                                         sizeof(PI_CONSUMER_BLOCK) +
                                         (PI_ALIGN_K_DESC_BLK - 1);
-        bp->kmalloced = top_v = dma_zalloc_coherent(bp->bus_dev, alloc_size,
-                                                    &bp->kmalloced_dma,
-                                                    GFP_ATOMIC);
+        bp->kmalloced = top_v = dma_alloc_coherent(bp->bus_dev, alloc_size,
+                                                   &bp->kmalloced_dma,
+                                                   GFP_ATOMIC);
         if (top_v == NULL)
                 return DFX_K_FAILURE;
 
diff --git a/drivers/net/fddi/skfp/skfddi.c b/drivers/net/fddi/skfp/skfddi.c
index 72433f3efc74..5d661f60b101 100644
--- a/drivers/net/fddi/skfp/skfddi.c
+++ b/drivers/net/fddi/skfp/skfddi.c
@@ -409,10 +409,10 @@ static  int skfp_driver_init(struct net_device *dev)
         if (bp->SharedMemSize > 0) {
                 bp->SharedMemSize += 16;        // for descriptor alignment
 
-                bp->SharedMemAddr = dma_zalloc_coherent(&bp->pdev.dev,
-                                                        bp->SharedMemSize,
-                                                        &bp->SharedMemDMA,
-                                                        GFP_ATOMIC);
+                bp->SharedMemAddr = dma_alloc_coherent(&bp->pdev.dev,
+                                                       bp->SharedMemSize,
+                                                       &bp->SharedMemDMA,
+                                                       GFP_ATOMIC);
                 if (!bp->SharedMemAddr) {
                         printk("could not allocate mem for ");
                         printk("hardware module: %ld byte\n",
diff --git a/drivers/net/vmxnet3/vmxnet3_drv.c b/drivers/net/vmxnet3/vmxnet3_drv.c
index e454dfc9ad8f..89984fcab01e 100644
--- a/drivers/net/vmxnet3/vmxnet3_drv.c
+++ b/drivers/net/vmxnet3/vmxnet3_drv.c
@@ -535,8 +535,8 @@ vmxnet3_tq_create(struct vmxnet3_tx_queue *tq,
         }
 
         sz = tq->tx_ring.size * sizeof(tq->buf_info[0]);
-        tq->buf_info = dma_zalloc_coherent(&adapter->pdev->dev, sz,
-                                           &tq->buf_info_pa, GFP_KERNEL);
+        tq->buf_info = dma_alloc_coherent(&adapter->pdev->dev, sz,
+                                          &tq->buf_info_pa, GFP_KERNEL);
         if (!tq->buf_info)
                 goto err;
 
@@ -1815,8 +1815,8 @@ vmxnet3_rq_create(struct vmxnet3_rx_queue *rq, struct vmxnet3_adapter *adapter)
 
         sz = sizeof(struct vmxnet3_rx_buf_info) * (rq->rx_ring[0].size +
                                                    rq->rx_ring[1].size);
-        bi = dma_zalloc_coherent(&adapter->pdev->dev, sz, &rq->buf_info_pa,
-                                 GFP_KERNEL);
+        bi = dma_alloc_coherent(&adapter->pdev->dev, sz, &rq->buf_info_pa,
+                                GFP_KERNEL);
         if (!bi)
                 goto err;
 
diff --git a/drivers/net/wan/fsl_ucc_hdlc.c b/drivers/net/wan/fsl_ucc_hdlc.c
index 839fa7715709..be6485428198 100644
--- a/drivers/net/wan/fsl_ucc_hdlc.c
+++ b/drivers/net/wan/fsl_ucc_hdlc.c
@@ -279,10 +279,9 @@ static int uhdlc_init(struct ucc_hdlc_private *priv)
         iowrite16be(DEFAULT_HDLC_ADDR, &priv->ucc_pram->haddr4);
 
         /* Get BD buffer */
-        bd_buffer = dma_zalloc_coherent(priv->dev,
-                                        (RX_BD_RING_LEN + TX_BD_RING_LEN) *
-                                        MAX_RX_BUF_LENGTH,
-                                        &bd_dma_addr, GFP_KERNEL);
+        bd_buffer = dma_alloc_coherent(priv->dev,
+                                       (RX_BD_RING_LEN + TX_BD_RING_LEN) * MAX_RX_BUF_LENGTH,
+                                       &bd_dma_addr, GFP_KERNEL);
 
         if (!bd_buffer) {
                 dev_err(priv->dev, "Could not allocate buffer descriptors\n");
diff --git a/drivers/net/wireless/ath/ath10k/ce.c b/drivers/net/wireless/ath/ath10k/ce.c
index f6d3ecbdd3a3..2a5668b4f6bc 100644
--- a/drivers/net/wireless/ath/ath10k/ce.c
+++ b/drivers/net/wireless/ath/ath10k/ce.c
@@ -1553,10 +1553,9 @@ ath10k_ce_alloc_dest_ring(struct ath10k *ar, unsigned int ce_id,
          * coherent DMA are unsupported
          */
         dest_ring->base_addr_owner_space_unaligned =
-                dma_zalloc_coherent(ar->dev,
-                                    (nentries * sizeof(struct ce_desc) +
-                                     CE_DESC_RING_ALIGN),
-                                    &base_addr, GFP_KERNEL);
+                dma_alloc_coherent(ar->dev,
+                                   (nentries * sizeof(struct ce_desc) + CE_DESC_RING_ALIGN),
+                                   &base_addr, GFP_KERNEL);
         if (!dest_ring->base_addr_owner_space_unaligned) {
                 kfree(dest_ring);
                 return ERR_PTR(-ENOMEM);
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index e49b36752ba2..49758490eaba 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
@@ -5169,10 +5169,10 @@ static int ath10k_add_interface(struct ieee80211_hw *hw,
         if (vif->type == NL80211_IFTYPE_ADHOC ||
             vif->type == NL80211_IFTYPE_MESH_POINT ||
             vif->type == NL80211_IFTYPE_AP) {
-                arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
-                                                        IEEE80211_MAX_FRAME_LEN,
-                                                        &arvif->beacon_paddr,
-                                                        GFP_ATOMIC);
+                arvif->beacon_buf = dma_alloc_coherent(ar->dev,
+                                                       IEEE80211_MAX_FRAME_LEN,
+                                                       &arvif->beacon_paddr,
+                                                       GFP_ATOMIC);
                 if (!arvif->beacon_buf) {
                         ret = -ENOMEM;
                         ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c
index 01b4edb00e9e..39e0b1cc2a12 100644
--- a/drivers/net/wireless/ath/ath10k/pci.c
+++ b/drivers/net/wireless/ath/ath10k/pci.c
@@ -936,8 +936,7 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
          */
         alloc_nbytes = min_t(unsigned int, nbytes, DIAG_TRANSFER_LIMIT);
 
-        data_buf = (unsigned char *)dma_zalloc_coherent(ar->dev,
-                                                       alloc_nbytes,
+        data_buf = (unsigned char *)dma_alloc_coherent(ar->dev, alloc_nbytes,
                                                        &ce_data_base,
                                                        GFP_ATOMIC);
 
diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index ba837403e266..8e236d158ca6 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
@@ -5193,7 +5193,7 @@ static int ath10k_wmi_alloc_chunk(struct ath10k *ar, u32 req_id,
         void *vaddr;
 
         pool_size = num_units * round_up(unit_len, 4);
-        vaddr = dma_zalloc_coherent(ar->dev, pool_size, &paddr, GFP_KERNEL);
+        vaddr = dma_alloc_coherent(ar->dev, pool_size, &paddr, GFP_KERNEL);
 
         if (!vaddr)
                 return -ENOMEM;
diff --git a/drivers/net/wireless/ath/wcn36xx/dxe.c b/drivers/net/wireless/ath/wcn36xx/dxe.c
index 5ab3e31c9ffa..bab30f7a443c 100644
--- a/drivers/net/wireless/ath/wcn36xx/dxe.c
+++ b/drivers/net/wireless/ath/wcn36xx/dxe.c
@@ -174,9 +174,8 @@ static int wcn36xx_dxe_init_descs(struct device *dev, struct wcn36xx_dxe_ch *wcn
         int i;
 
         size = wcn_ch->desc_num * sizeof(struct wcn36xx_dxe_desc);
-        wcn_ch->cpu_addr = dma_zalloc_coherent(dev, size,
-                                               &wcn_ch->dma_addr,
-                                               GFP_KERNEL);
+        wcn_ch->cpu_addr = dma_alloc_coherent(dev, size, &wcn_ch->dma_addr,
+                                              GFP_KERNEL);
         if (!wcn_ch->cpu_addr)
                 return -ENOMEM;
 
@@ -627,9 +626,9 @@ int wcn36xx_dxe_allocate_mem_pools(struct wcn36xx *wcn)
                 16 - (WCN36XX_BD_CHUNK_SIZE % 8);
 
         s = wcn->mgmt_mem_pool.chunk_size * WCN36XX_DXE_CH_DESC_NUMB_TX_H;
-        cpu_addr = dma_zalloc_coherent(wcn->dev, s,
-                                       &wcn->mgmt_mem_pool.phy_addr,
-                                       GFP_KERNEL);
+        cpu_addr = dma_alloc_coherent(wcn->dev, s,
+                                      &wcn->mgmt_mem_pool.phy_addr,
+                                      GFP_KERNEL);
         if (!cpu_addr)
                 goto out_err;
 
@@ -642,9 +641,9 @@ int wcn36xx_dxe_allocate_mem_pools(struct wcn36xx *wcn)
                 16 - (WCN36XX_BD_CHUNK_SIZE % 8);
 
         s = wcn->data_mem_pool.chunk_size * WCN36XX_DXE_CH_DESC_NUMB_TX_L;
-        cpu_addr = dma_zalloc_coherent(wcn->dev, s,
-                                       &wcn->data_mem_pool.phy_addr,
-                                       GFP_KERNEL);
+        cpu_addr = dma_alloc_coherent(wcn->dev, s,
+                                      &wcn->data_mem_pool.phy_addr,
+                                      GFP_KERNEL);
         if (!cpu_addr)
                 goto out_err;
 
diff --git a/drivers/net/wireless/ath/wil6210/txrx_edma.c b/drivers/net/wireless/ath/wil6210/txrx_edma.c
index 05a8348bd7b9..3380aaef456c 100644
--- a/drivers/net/wireless/ath/wil6210/txrx_edma.c
+++ b/drivers/net/wireless/ath/wil6210/txrx_edma.c
@@ -99,7 +99,7 @@ static int wil_sring_alloc(struct wil6210_priv *wil,
         /* Status messages are allocated and initialized to 0. This is necessary
          * since DR bit should be initialized to 0.
          */
-        sring->va = dma_zalloc_coherent(dev, sz, &sring->pa, GFP_KERNEL);
+        sring->va = dma_alloc_coherent(dev, sz, &sring->pa, GFP_KERNEL);
         if (!sring->va)
                 return -ENOMEM;
 
@@ -381,15 +381,15 @@ static int wil_ring_alloc_desc_ring(struct wil6210_priv *wil,
         if (!ring->ctx)
                 goto err;
 
-        ring->va = dma_zalloc_coherent(dev, sz, &ring->pa, GFP_KERNEL);
+        ring->va = dma_alloc_coherent(dev, sz, &ring->pa, GFP_KERNEL);
         if (!ring->va)
                 goto err_free_ctx;
 
         if (ring->is_rx) {
                 sz = sizeof(*ring->edma_rx_swtail.va);
                 ring->edma_rx_swtail.va =
-                        dma_zalloc_coherent(dev, sz, &ring->edma_rx_swtail.pa,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(dev, sz, &ring->edma_rx_swtail.pa,
+                                           GFP_KERNEL);
                 if (!ring->edma_rx_swtail.va)
                         goto err_free_va;
         }
diff --git a/drivers/net/wireless/broadcom/b43/dma.c b/drivers/net/wireless/broadcom/b43/dma.c
index dfc4c34298d4..b34e51933257 100644
--- a/drivers/net/wireless/broadcom/b43/dma.c
+++ b/drivers/net/wireless/broadcom/b43/dma.c
@@ -431,9 +431,9 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
         u16 ring_mem_size = (ring->type == B43_DMA_64BIT) ?
                                 B43_DMA64_RINGMEMSIZE : B43_DMA32_RINGMEMSIZE;
 
-        ring->descbase = dma_zalloc_coherent(ring->dev->dev->dma_dev,
-                                             ring_mem_size, &(ring->dmabase),
-                                             GFP_KERNEL);
+        ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,
+                                            ring_mem_size, &(ring->dmabase),
+                                            GFP_KERNEL);
         if (!ring->descbase)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/broadcom/b43legacy/dma.c b/drivers/net/wireless/broadcom/b43legacy/dma.c
index 1b1da7d83652..2ce1537d983c 100644
--- a/drivers/net/wireless/broadcom/b43legacy/dma.c
+++ b/drivers/net/wireless/broadcom/b43legacy/dma.c
@@ -331,9 +331,9 @@ void free_descriptor_buffer(struct b43legacy_dmaring *ring,
 static int alloc_ringmemory(struct b43legacy_dmaring *ring)
 {
         /* GFP flags must match the flags in free_ringmemory()! */
-        ring->descbase = dma_zalloc_coherent(ring->dev->dev->dma_dev,
-                                             B43legacy_DMA_RINGMEMSIZE,
-                                             &(ring->dmabase), GFP_KERNEL);
+        ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,
+                                            B43legacy_DMA_RINGMEMSIZE,
+                                            &(ring->dmabase), GFP_KERNEL);
         if (!ring->descbase)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
index 16d7dda965d8..0f69b3fa296e 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
@@ -1281,10 +1281,10 @@ static int brcmf_pcie_init_scratchbuffers(struct brcmf_pciedev_info *devinfo)
         u32 addr;
 
         devinfo->shared.scratch =
-                dma_zalloc_coherent(&devinfo->pdev->dev,
-                                        BRCMF_DMA_D2H_SCRATCH_BUF_LEN,
-                                        &devinfo->shared.scratch_dmahandle,
-                                        GFP_KERNEL);
+                dma_alloc_coherent(&devinfo->pdev->dev,
+                                   BRCMF_DMA_D2H_SCRATCH_BUF_LEN,
+                                   &devinfo->shared.scratch_dmahandle,
+                                   GFP_KERNEL);
         if (!devinfo->shared.scratch)
                 goto fail;
 
@@ -1298,10 +1298,10 @@ static int brcmf_pcie_init_scratchbuffers(struct brcmf_pciedev_info *devinfo)
         brcmf_pcie_write_tcm32(devinfo, addr, BRCMF_DMA_D2H_SCRATCH_BUF_LEN);
 
         devinfo->shared.ringupd =
-                dma_zalloc_coherent(&devinfo->pdev->dev,
-                                        BRCMF_DMA_D2H_RINGUPD_BUF_LEN,
-                                        &devinfo->shared.ringupd_dmahandle,
-                                        GFP_KERNEL);
+                dma_alloc_coherent(&devinfo->pdev->dev,
+                                   BRCMF_DMA_D2H_RINGUPD_BUF_LEN,
+                                   &devinfo->shared.ringupd_dmahandle,
+                                   GFP_KERNEL);
         if (!devinfo->shared.ringupd)
                 goto fail;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/rx.c b/drivers/net/wireless/intel/iwlwifi/pcie/rx.c
index e965cc588850..9e850c25877b 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/rx.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/rx.c
@@ -711,30 +711,24 @@ static int iwl_pcie_alloc_rxq_dma(struct iwl_trans *trans,
          * Allocate the circular buffer of Read Buffer Descriptors
          * (RBDs)
          */
-        rxq->bd = dma_zalloc_coherent(dev,
-                                      free_size * rxq->queue_size,
-                                      &rxq->bd_dma, GFP_KERNEL);
+        rxq->bd = dma_alloc_coherent(dev, free_size * rxq->queue_size,
+                                     &rxq->bd_dma, GFP_KERNEL);
         if (!rxq->bd)
                 goto err;
 
         if (trans->cfg->mq_rx_supported) {
-                rxq->used_bd = dma_zalloc_coherent(dev,
-                                                   (use_rx_td ?
-                                                   sizeof(*rxq->cd) :
-                                                   sizeof(__le32)) *
-                                                   rxq->queue_size,
-                                                   &rxq->used_bd_dma,
-                                                   GFP_KERNEL);
+                rxq->used_bd = dma_alloc_coherent(dev,
+                                                  (use_rx_td ? sizeof(*rxq->cd) : sizeof(__le32)) * rxq->queue_size,
+                                                  &rxq->used_bd_dma,
+                                                  GFP_KERNEL);
                 if (!rxq->used_bd)
                         goto err;
         }
 
         /* Allocate the driver's pointer to receive buffer status */
-        rxq->rb_stts = dma_zalloc_coherent(dev, use_rx_td ?
-                                           sizeof(__le16) :
-                                           sizeof(struct iwl_rb_status),
-                                           &rxq->rb_stts_dma,
-                                           GFP_KERNEL);
+        rxq->rb_stts = dma_alloc_coherent(dev,
+                                          use_rx_td ? sizeof(__le16) : sizeof(struct iwl_rb_status),
+                                          &rxq->rb_stts_dma, GFP_KERNEL);
         if (!rxq->rb_stts)
                 goto err;
 
@@ -742,16 +736,14 @@ static int iwl_pcie_alloc_rxq_dma(struct iwl_trans *trans,
                 return 0;
 
         /* Allocate the driver's pointer to TR tail */
-        rxq->tr_tail = dma_zalloc_coherent(dev, sizeof(__le16),
-                                           &rxq->tr_tail_dma,
-                                           GFP_KERNEL);
+        rxq->tr_tail = dma_alloc_coherent(dev, sizeof(__le16),
+                                          &rxq->tr_tail_dma, GFP_KERNEL);
         if (!rxq->tr_tail)
                 goto err;
 
         /* Allocate the driver's pointer to CR tail */
-        rxq->cr_tail = dma_zalloc_coherent(dev, sizeof(__le16),
-                                           &rxq->cr_tail_dma,
-                                           GFP_KERNEL);
+        rxq->cr_tail = dma_alloc_coherent(dev, sizeof(__le16),
+                                          &rxq->cr_tail_dma, GFP_KERNEL);
         if (!rxq->cr_tail)
                 goto err;
         /*
@@ -1947,9 +1939,8 @@ int iwl_pcie_alloc_ict(struct iwl_trans *trans)
         struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
 
         trans_pcie->ict_tbl =
-                dma_zalloc_coherent(trans->dev, ICT_SIZE,
-                                   &trans_pcie->ict_tbl_dma,
-                                   GFP_KERNEL);
+                dma_alloc_coherent(trans->dev, ICT_SIZE,
+                                   &trans_pcie->ict_tbl_dma, GFP_KERNEL);
         if (!trans_pcie->ict_tbl)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c b/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c
index 528cb0401df1..4956a54151cb 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c
@@ -119,9 +119,9 @@ static int rt2x00mmio_alloc_queue_dma(struct rt2x00_dev *rt2x00dev,
         /*
          * Allocate DMA memory for descriptor and buffer.
          */
-        addr = dma_zalloc_coherent(rt2x00dev->dev,
-                                   queue->limit * queue->desc_size, &dma,
-                                   GFP_KERNEL);
+        addr = dma_alloc_coherent(rt2x00dev->dev,
+                                  queue->limit * queue->desc_size, &dma,
+                                  GFP_KERNEL);
         if (!addr)
                 return -ENOMEM;