drivers:net: Remove dma_alloc_coherent OOM messages
authorJoe Perches <joe@perches.com>
Thu, 14 Mar 2013 13:07:21 +0000 (13:07 +0000)
committerDavid S. Miller <davem@davemloft.net>
Fri, 15 Mar 2013 12:56:58 +0000 (08:56 -0400)
I believe these error messages are already logged
on allocation failure by warn_alloc_failed and so
get a dump_stack on OOM.

Remove the unnecessary additional error logging.

Around these deletions:

o Alignment neatening.
o Remove unnecessary casts of dma_alloc_coherent.
o Hoist assigns from ifs.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
42 files changed:
drivers/net/ethernet/aeroflex/greth.c
drivers/net/ethernet/amd/sunlance.c
drivers/net/ethernet/apple/macmace.c
drivers/net/ethernet/broadcom/bcm63xx_enet.c
drivers/net/ethernet/cadence/at91_ether.c
drivers/net/ethernet/dec/tulip/xircom_cb.c
drivers/net/ethernet/emulex/benet/be_cmds.c
drivers/net/ethernet/emulex/benet/be_ethtool.c
drivers/net/ethernet/emulex/benet/be_main.c
drivers/net/ethernet/freescale/fec.c
drivers/net/ethernet/freescale/gianfar.c
drivers/net/ethernet/ibm/emac/mal.c
drivers/net/ethernet/ibm/ibmveth.c
drivers/net/ethernet/intel/e1000/e1000_main.c
drivers/net/ethernet/intel/ixgb/ixgb_main.c
drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
drivers/net/ethernet/marvell/mvneta.c
drivers/net/ethernet/marvell/pxa168_eth.c
drivers/net/ethernet/mellanox/mlx4/cmd.c
drivers/net/ethernet/natsemi/jazzsonic.c
drivers/net/ethernet/natsemi/macsonic.c
drivers/net/ethernet/natsemi/xtsonic.c
drivers/net/ethernet/nuvoton/w90p910_ether.c
drivers/net/ethernet/nxp/lpc_eth.c
drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
drivers/net/ethernet/qlogic/qlcnic/qlcnic_minidump.c
drivers/net/ethernet/renesas/sh_eth.c
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
drivers/net/ethernet/sun/sunbmac.c
drivers/net/ethernet/sun/sunhme.c
drivers/net/ethernet/tundra/tsi108_eth.c
drivers/net/ethernet/xilinx/ll_temac_main.c
drivers/net/ethernet/xilinx/xilinx_axienet_main.c
drivers/net/fddi/defxx.c
drivers/net/irda/bfin_sir.c
drivers/net/irda/smsc-ircc2.c
drivers/net/wireless/ath/wil6210/txrx.c
drivers/net/wireless/b43legacy/dma.c
drivers/net/wireless/iwlegacy/3945.c
drivers/net/wireless/iwlegacy/common.c
drivers/net/wireless/iwlwifi/pcie/tx.c

index 0be2195e50340c24c5c2f5403b2f32b12c403c8e..3a9fbacc372908580911f2732cedc71e4b3a4a4a 100644 (file)
@@ -1464,14 +1464,10 @@ static int greth_of_probe(struct platform_device *ofdev)
        }
 
        /* Allocate TX descriptor ring in coherent memory */
-       greth->tx_bd_base = (struct greth_bd *) dma_alloc_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) {
-               if (netif_msg_probe(greth))
-                       dev_err(&dev->dev, "could not allocate descriptor memory.\n");
                err = -ENOMEM;
                goto error3;
        }
@@ -1479,14 +1475,10 @@ static int greth_of_probe(struct platform_device *ofdev)
        memset(greth->tx_bd_base, 0, 1024);
 
        /* Allocate RX descriptor ring in coherent memory */
-       greth->rx_bd_base = (struct greth_bd *) dma_alloc_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) {
-               if (netif_msg_probe(greth))
-                       dev_err(greth->dev, "could not allocate descriptor memory.\n");
                err = -ENOMEM;
                goto error4;
        }
index 70d543063993091e1fa23d1ffec4b8436d05d2a0..f47b780892e97f4a4e5ca186e08ee1679f4eee6c 100644 (file)
@@ -1373,10 +1373,9 @@ static int sparc_lance_probe_one(struct platform_device *op,
                        dma_alloc_coherent(&op->dev,
                                           sizeof(struct lance_init_block),
                                           &lp->init_block_dvma, GFP_ATOMIC);
-               if (!lp->init_block_mem) {
-                       printk(KERN_ERR "SunLance: Cannot allocate consistent DMA memory.\n");
+               if (!lp->init_block_mem)
                        goto fail;
-               }
+
                lp->pio_buffer = 0;
                lp->init_ring = lance_init_ring_dvma;
                lp->rx = lance_rx_dvma;
index a206779c68cf2d48f5a6bcc6f98b99dd2c98426f..4ce8ceb6220584c1e1af51217f91cfa97f4e5783 100644 (file)
@@ -386,20 +386,16 @@ static int mace_open(struct net_device *dev)
        /* Allocate the DMA ring buffers */
 
        mp->tx_ring = dma_alloc_coherent(mp->device,
-                       N_TX_RING * MACE_BUFF_SIZE,
-                       &mp->tx_ring_phys, GFP_KERNEL);
-       if (mp->tx_ring == NULL) {
-               printk(KERN_ERR "%s: unable to allocate DMA tx buffers\n", dev->name);
+                                        N_TX_RING * MACE_BUFF_SIZE,
+                                        &mp->tx_ring_phys, GFP_KERNEL);
+       if (mp->tx_ring == NULL)
                goto out1;
-       }
 
        mp->rx_ring = dma_alloc_coherent(mp->device,
-                       N_RX_RING * MACE_BUFF_SIZE,
-                       &mp->rx_ring_phys, GFP_KERNEL);
-       if (mp->rx_ring == NULL) {
-               printk(KERN_ERR "%s: unable to allocate DMA rx buffers\n", dev->name);
+                                        N_RX_RING * MACE_BUFF_SIZE,
+                                        &mp->rx_ring_phys, GFP_KERNEL);
+       if (mp->rx_ring == NULL)
                goto out2;
-       }
 
        mace_dma_off(dev);
 
index db343a1d083576c5e511dcf0d2c5175d98c84a37..79cf620ab44992f8ae8544992967af7386d02d81 100644 (file)
@@ -864,7 +864,6 @@ static int bcm_enet_open(struct net_device *dev)
        size = priv->rx_ring_size * sizeof(struct bcm_enet_desc);
        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;
                goto out_freeirq_tx;
        }
@@ -877,7 +876,6 @@ static int bcm_enet_open(struct net_device *dev)
        size = priv->tx_ring_size * sizeof(struct bcm_enet_desc);
        p = dma_alloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
        if (!p) {
-               dev_err(kdev, "cannot allocate tx ring\n");
                ret = -ENOMEM;
                goto out_free_rx_ring;
        }
index 5bd7786e8413c091e6f1cd9ea13b183b2e093ef5..c6e40d65a3df955c3aacd631fc2a96be75995b8e 100644 (file)
@@ -47,22 +47,19 @@ static int at91ether_start(struct net_device *dev)
        int i;
 
        lp->rx_ring = dma_alloc_coherent(&lp->pdev->dev,
-                                       MAX_RX_DESCR * sizeof(struct macb_dma_desc),
-                                       &lp->rx_ring_dma, GFP_KERNEL);
-       if (!lp->rx_ring) {
-               netdev_err(dev, "unable to alloc rx ring DMA buffer\n");
+                                        (MAX_RX_DESCR *
+                                         sizeof(struct macb_dma_desc)),
+                                        &lp->rx_ring_dma, GFP_KERNEL);
+       if (!lp->rx_ring)
                return -ENOMEM;
-       }
 
        lp->rx_buffers = dma_alloc_coherent(&lp->pdev->dev,
-                                       MAX_RX_DESCR * MAX_RBUFF_SZ,
-                                       &lp->rx_buffers_dma, GFP_KERNEL);
+                                           MAX_RX_DESCR * MAX_RBUFF_SZ,
+                                           &lp->rx_buffers_dma, GFP_KERNEL);
        if (!lp->rx_buffers) {
-               netdev_err(dev, "unable to alloc rx data DMA buffer\n");
-
                dma_free_coherent(&lp->pdev->dev,
-                                       MAX_RX_DESCR * sizeof(struct macb_dma_desc),
-                                       lp->rx_ring, lp->rx_ring_dma);
+                                 MAX_RX_DESCR * sizeof(struct macb_dma_desc),
+                                 lp->rx_ring, lp->rx_ring_dma);
                lp->rx_ring = NULL;
                return -ENOMEM;
        }
index 88feced9a6293432e3dd5316a8ec48ab284ca3e7..cdbcd16431411bf48ad3cf459c8cb12f3adbf537 100644 (file)
@@ -236,17 +236,14 @@ static int xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id)
        private->rx_buffer = dma_alloc_coherent(d, 8192,
                                                &private->rx_dma_handle,
                                                GFP_KERNEL);
-       if (private->rx_buffer == NULL) {
-               pr_err("%s: no memory for rx buffer\n", __func__);
+       if (private->rx_buffer == NULL)
                goto rx_buf_fail;
-       }
+
        private->tx_buffer = dma_alloc_coherent(d, 8192,
                                                &private->tx_dma_handle,
                                                GFP_KERNEL);
-       if (private->tx_buffer == NULL) {
-               pr_err("%s: no memory for tx buffer\n", __func__);
+       if (private->tx_buffer == NULL)
                goto tx_buf_fail;
-       }
 
        SET_NETDEV_DEV(dev, &pdev->dev);
 
index 99163646113f3168437da46bae1059a7f7f53fea..f286ad2da1ff283dffba78c6db00630cefe3d534 100644 (file)
@@ -2667,10 +2667,8 @@ int be_cmd_set_mac_list(struct be_adapter *adapter, u8 *mac_array,
        cmd.size = sizeof(struct be_cmd_req_set_mac_list);
        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size,
                        &cmd.dma, GFP_KERNEL);
-       if (!cmd.va) {
-               dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
+       if (!cmd.va)
                return -ENOMEM;
-       }
 
        spin_lock_bh(&adapter->mcc_lock);
 
index 053f00d006c0bda9f7de262055787f04f4f1148f..07b7f27cb0b90885c965e05fbb3bc4803885e344 100644 (file)
@@ -719,10 +719,8 @@ be_test_ddr_dma(struct be_adapter *adapter)
        ddrdma_cmd.size = sizeof(struct be_cmd_req_ddrdma_test);
        ddrdma_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, ddrdma_cmd.size,
                                           &ddrdma_cmd.dma, GFP_KERNEL);
-       if (!ddrdma_cmd.va) {
-               dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
+       if (!ddrdma_cmd.va)
                return -ENOMEM;
-       }
 
        for (i = 0; i < 2; i++) {
                ret = be_cmd_ddr_dma_test(adapter, pattern[i],
@@ -845,11 +843,8 @@ be_read_eeprom(struct net_device *netdev, struct ethtool_eeprom *eeprom,
        eeprom_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, eeprom_cmd.size,
                                           &eeprom_cmd.dma, GFP_KERNEL);
 
-       if (!eeprom_cmd.va) {
-               dev_err(&adapter->pdev->dev,
-                       "Memory allocation failure. Could not read eeprom\n");
+       if (!eeprom_cmd.va)
                return -ENOMEM;
-       }
 
        status = be_cmd_get_seeprom_data(adapter, &eeprom_cmd);
 
index c71b180f4678ae168b38af4c4450e5eeb24d2e11..2dfa205c5b99065504394a4ca3269e4754c4ab14 100644 (file)
@@ -3464,11 +3464,9 @@ static 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_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
-                                               &flash_cmd.dma, GFP_KERNEL);
+                                         &flash_cmd.dma, GFP_KERNEL);
        if (!flash_cmd.va) {
                status = -ENOMEM;
-               dev_err(&adapter->pdev->dev,
-                       "Memory allocation failure while flashing\n");
                goto lancer_fw_exit;
        }
 
@@ -3570,8 +3568,6 @@ static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
                                          &flash_cmd.dma, GFP_KERNEL);
        if (!flash_cmd.va) {
                status = -ENOMEM;
-               dev_err(&adapter->pdev->dev,
-                       "Memory allocation failure while flashing\n");
                goto be_fw_exit;
        }
 
index e6224949891f6a174b02d624cbffe474eac8e2e9..69a4adedad83066b19f2434341cbcce88c07928a 100644 (file)
@@ -1594,11 +1594,9 @@ static int fec_enet_init(struct net_device *ndev)
 
        /* Allocate memory for buffer descriptors. */
        cbd_base = dma_alloc_coherent(NULL, PAGE_SIZE, &fep->bd_dma,
-                       GFP_KERNEL);
-       if (!cbd_base) {
-               printk("FEC: allocate descriptor memory failed?\n");
+                                     GFP_KERNEL);
+       if (!cbd_base)
                return -ENOMEM;
-       }
 
        spin_lock_init(&fep->hw_lock);
 
index d2c5441d1bf0a47e1f2d7de789bf1130198da5ee..1b468a82a68fb90d72d1b1fa80d0aee25d38dc1b 100644 (file)
@@ -245,14 +245,13 @@ static int gfar_alloc_skb_resources(struct net_device *ndev)
 
        /* Allocate memory for the buffer descriptors */
        vaddr = dma_alloc_coherent(dev,
-                       sizeof(struct txbd8) * priv->total_tx_ring_size +
-                       sizeof(struct rxbd8) * priv->total_rx_ring_size,
-                       &addr, GFP_KERNEL);
-       if (!vaddr) {
-               netif_err(priv, ifup, ndev,
-                         "Could not allocate buffer descriptors!\n");
+                                  (priv->total_tx_ring_size *
+                                   sizeof(struct txbd8)) +
+                                  (priv->total_rx_ring_size *
+                                   sizeof(struct rxbd8)),
+                                  &addr, GFP_KERNEL);
+       if (!vaddr)
                return -ENOMEM;
-       }
 
        for (i = 0; i < priv->num_tx_queues; i++) {
                tx_queue = priv->tx_queue[i];
index 1f7ecf57181e291d62f4567581169a5b52244ddd..cc2db5c04d9cf80fa239536b61149093268026b1 100644 (file)
@@ -637,13 +637,9 @@ 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_alloc_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) {
-               printk(KERN_ERR
-                      "mal%d: out of memory allocating RX/TX descriptors!\n",
-                      index);
                err = -ENOMEM;
                goto fail_unmap;
        }
index c859771a9902e21e2f5e03a7c0901c06788e6172..302d594010652d829f5cc73d0b7b0df7ebaebf80 100644 (file)
@@ -556,11 +556,9 @@ static int ibmveth_open(struct net_device *netdev)
        adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) *
                                                rxq_entries;
        adapter->rx_queue.queue_addr =
-           dma_alloc_coherent(dev, adapter->rx_queue.queue_len,
-                              &adapter->rx_queue.queue_dma, GFP_KERNEL);
-
+               dma_alloc_coherent(dev, adapter->rx_queue.queue_len,
+                                  &adapter->rx_queue.queue_dma, GFP_KERNEL);
        if (!adapter->rx_queue.queue_addr) {
-               netdev_err(netdev, "unable to allocate rx queue pages\n");
                rc = -ENOMEM;
                goto err_out;
        }
index 8502c625dbef3d10dd28752929bd126f438fa89d..d98e1d0996d4d4034cec65c9a61d49a217cbcbf5 100644 (file)
@@ -1516,8 +1516,6 @@ static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
        if (!txdr->desc) {
 setup_tx_desc_die:
                vfree(txdr->buffer_info);
-               e_err(probe, "Unable to allocate memory for the Tx descriptor "
-                     "ring\n");
                return -ENOMEM;
        }
 
@@ -1707,10 +1705,7 @@ static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
 
        rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
                                        GFP_KERNEL);
-
        if (!rxdr->desc) {
-               e_err(probe, "Unable to allocate memory for the Rx descriptor "
-                     "ring\n");
 setup_rx_desc_die:
                vfree(rxdr->buffer_info);
                return -ENOMEM;
@@ -1729,8 +1724,6 @@ setup_rx_desc_die:
                if (!rxdr->desc) {
                        dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
                                          olddma);
-                       e_err(probe, "Unable to allocate memory for the Rx "
-                             "descriptor ring\n");
                        goto setup_rx_desc_die;
                }
 
index ea48083734359e52b229f592e84abf7654a82523..e23f0234cb2711061fefae7f731dd96e83d3fa8b 100644 (file)
@@ -720,8 +720,6 @@ ixgb_setup_tx_resources(struct ixgb_adapter *adapter)
                                        GFP_KERNEL);
        if (!txdr->desc) {
                vfree(txdr->buffer_info);
-               netif_err(adapter, probe, adapter->netdev,
-                         "Unable to allocate transmit descriptor memory\n");
                return -ENOMEM;
        }
        memset(txdr->desc, 0, txdr->size);
@@ -807,8 +805,6 @@ ixgb_setup_rx_resources(struct ixgb_adapter *adapter)
 
        if (!rxdr->desc) {
                vfree(rxdr->buffer_info);
-               netif_err(adapter, probe, adapter->netdev,
-                         "Unable to allocate receive descriptors\n");
                return -ENOMEM;
        }
        memset(rxdr->desc, 0, rxdr->size);
index 2635b8303515bb3051f8e3ff48612346a80ab902..ac0c315659de4827a1c9b29aaeba58d29299f090 100644 (file)
@@ -2423,9 +2423,6 @@ int ixgbevf_setup_rx_resources(struct ixgbevf_adapter *adapter,
                                           &rx_ring->dma, GFP_KERNEL);
 
        if (!rx_ring->desc) {
-               hw_dbg(&adapter->hw,
-                      "Unable to allocate memory for "
-                      "the receive descriptor ring\n");
                vfree(rx_ring->rx_buffer_info);
                rx_ring->rx_buffer_info = NULL;
                goto alloc_failed;
index cd345b8969bcaa75643a34da5819af5d569a1523..e48261e468f355ff00d321e23fa2f3451839c4b7 100644 (file)
@@ -1969,13 +1969,8 @@ static int mvneta_rxq_init(struct mvneta_port *pp,
        rxq->descs = dma_alloc_coherent(pp->dev->dev.parent,
                                        rxq->size * MVNETA_DESC_ALIGNED_SIZE,
                                        &rxq->descs_phys, GFP_KERNEL);
-       if (rxq->descs == NULL) {
-               netdev_err(pp->dev,
-                          "rxq=%d: Can't allocate %d bytes for %d RX descr\n",
-                          rxq->id, rxq->size * MVNETA_DESC_ALIGNED_SIZE,
-                          rxq->size);
+       if (rxq->descs == NULL)
                return -ENOMEM;
-       }
 
        BUG_ON(rxq->descs !=
               PTR_ALIGN(rxq->descs, MVNETA_CPU_D_CACHE_LINE_SIZE));
@@ -2029,13 +2024,8 @@ static int mvneta_txq_init(struct mvneta_port *pp,
        txq->descs = dma_alloc_coherent(pp->dev->dev.parent,
                                        txq->size * MVNETA_DESC_ALIGNED_SIZE,
                                        &txq->descs_phys, GFP_KERNEL);
-       if (txq->descs == NULL) {
-               netdev_err(pp->dev,
-                          "txQ=%d: Can't allocate %d bytes for %d TX descr\n",
-                          txq->id, txq->size * MVNETA_DESC_ALIGNED_SIZE,
-                          txq->size);
+       if (txq->descs == NULL)
                return -ENOMEM;
-       }
 
        /* Make sure descriptor address is cache line size aligned  */
        BUG_ON(txq->descs !=
index 037ed866c22ffa7cfdd57b54fb45216a0a3dd729..3ae4c7f0834d132159a35ea76375dca05689bab8 100644 (file)
@@ -1024,11 +1024,9 @@ static int rxq_init(struct net_device *dev)
        pep->rx_desc_area_size = size;
        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) {
-               printk(KERN_ERR "%s: Cannot alloc RX ring (size %d bytes)\n",
-                      dev->name, size);
+       if (!pep->p_rx_desc_area)
                goto out;
-       }
+
        memset((void *)pep->p_rx_desc_area, 0, size);
        /* initialize the next_desc_ptr links in the Rx descriptors ring */
        p_rx_desc = pep->p_rx_desc_area;
@@ -1087,11 +1085,8 @@ static int txq_init(struct net_device *dev)
        pep->tx_desc_area_size = size;
        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) {
-               printk(KERN_ERR "%s: Cannot allocate Tx Ring (size %d bytes)\n",
-                      dev->name, size);
+       if (!pep->p_tx_desc_area)
                goto out;
-       }
        memset((void *)pep->p_tx_desc_area, 0, pep->tx_desc_area_size);
        /* Initialize the next_desc_ptr links in the Tx descriptors ring */
        p_tx_desc = pep->p_tx_desc_area;
index fdc5f23d8e9f26ae9a0fe30638a4359cb22eafa3..05267d716e8687883eaedff07b875bec57181e33 100644 (file)
@@ -1837,10 +1837,8 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
                priv->mfunc.vhcr = dma_alloc_coherent(&(dev->pdev->dev), PAGE_SIZE,
                                                      &priv->mfunc.vhcr_dma,
                                                      GFP_KERNEL);
-               if (!priv->mfunc.vhcr) {
-                       mlx4_err(dev, "Couldn't allocate VHCR.\n");
+               if (!priv->mfunc.vhcr)
                        goto err_hcr;
-               }
        }
 
        priv->cmd.pool = pci_pool_create("mlx4_cmd", dev->pdev,
index b0b36154636508e9f947c8358140f42fb7cbd1d5..c20766c2f65b91c57de2ba68ccb4d98058544059 100644 (file)
@@ -175,13 +175,13 @@ static int sonic_probe1(struct net_device *dev)
 
        /* Allocate the entire chunk of memory for the descriptors.
            Note that this cannot cross a 64K boundary. */
-       if ((lp->descriptors = dma_alloc_coherent(lp->device,
-                               SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
-                               &lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
-               printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n",
-                      dev_name(lp->device));
+       lp->descriptors = dma_alloc_coherent(lp->device,
+                                            SIZEOF_SONIC_DESC *
+                                            SONIC_BUS_SCALE(lp->dma_bitmode),
+                                            &lp->descriptors_laddr,
+                                            GFP_KERNEL);
+       if (lp->descriptors == NULL)
                goto out;
-       }
 
        /* Now set up the pointers to point to the appropriate places */
        lp->cda = lp->descriptors;
index 0ffde69c8d015e12db0e5943078b225fbfbd40e1..346a4e025c34100315b1ca2785d631d3bc5d3408 100644 (file)
@@ -202,13 +202,13 @@ static int macsonic_init(struct net_device *dev)
 
        /* Allocate the entire chunk of memory for the descriptors.
            Note that this cannot cross a 64K boundary. */
-       if ((lp->descriptors = dma_alloc_coherent(lp->device,
-                   SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
-                   &lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
-               printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n",
-                      dev_name(lp->device));
+       lp->descriptors = dma_alloc_coherent(lp->device,
+                                            SIZEOF_SONIC_DESC *
+                                            SONIC_BUS_SCALE(lp->dma_bitmode),
+                                            &lp->descriptors_laddr,
+                                            GFP_KERNEL);
+       if (lp->descriptors == NULL)
                return -ENOMEM;
-       }
 
        /* Now set up the pointers to point to the appropriate places */
        lp->cda = lp->descriptors;
index 5e4748e855f632f198adadda71221306fe6d4bcc..c2e0256fe3dfb423d1ba9011d7035379e1dd3f47 100644 (file)
@@ -197,14 +197,12 @@ static int __init sonic_probe1(struct net_device *dev)
         *  We also allocate extra space for a pointer to allow freeing
         *  this structure later on (in xtsonic_cleanup_module()).
         */
-       lp->descriptors =
-               dma_alloc_coherent(lp->device,
-                       SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
-                       &lp->descriptors_laddr, GFP_KERNEL);
-
+       lp->descriptors = dma_alloc_coherent(lp->device,
+                                            SIZEOF_SONIC_DESC *
+                                            SONIC_BUS_SCALE(lp->dma_bitmode),
+                                            &lp->descriptors_laddr,
+                                            GFP_KERNEL);
        if (lp->descriptors == NULL) {
-               printk(KERN_ERR "%s: couldn't alloc DMA memory for "
-                               " descriptors.\n", dev_name(lp->device));
                err = -ENOMEM;
                goto out;
        }
index 539d2028e45658287c599f35fca7e3ede8871384..3df8287b7452d77b69bee0262a9f950125020b8e 100644 (file)
@@ -287,23 +287,16 @@ static int w90p910_init_desc(struct net_device *dev)
        ether = netdev_priv(dev);
        pdev = ether->pdev;
 
-       ether->tdesc = (struct tran_pdesc *)
-               dma_alloc_coherent(&pdev->dev, sizeof(struct tran_pdesc),
-                                       &ether->tdesc_phys, GFP_KERNEL);
-
-       if (!ether->tdesc) {
-               dev_err(&pdev->dev, "Failed to allocate memory for tx desc\n");
+       ether->tdesc = dma_alloc_coherent(&pdev->dev, sizeof(struct tran_pdesc),
+                                         &ether->tdesc_phys, GFP_KERNEL);
+       if (!ether->tdesc)
                return -ENOMEM;
-       }
-
-       ether->rdesc = (struct recv_pdesc *)
-               dma_alloc_coherent(&pdev->dev, sizeof(struct recv_pdesc),
-                                       &ether->rdesc_phys, GFP_KERNEL);
 
+       ether->rdesc = dma_alloc_coherent(&pdev->dev, sizeof(struct recv_pdesc),
+                                         &ether->rdesc_phys, GFP_KERNEL);
        if (!ether->rdesc) {
-               dev_err(&pdev->dev, "Failed to allocate memory for rx desc\n");
                dma_free_coherent(&pdev->dev, sizeof(struct tran_pdesc),
-                                       ether->tdesc, ether->tdesc_phys);
+                                 ether->tdesc, ether->tdesc_phys);
                return -ENOMEM;
        }
 
index c4122c86f829293cc60d6dd48c72602d7dded49f..9c88c00c0a429dd96bc747a3f0171bb04a736a23 100644 (file)
@@ -1409,9 +1409,7 @@ static int lpc_eth_drv_probe(struct platform_device *pdev)
                        dma_alloc_coherent(&pldat->pdev->dev,
                                           pldat->dma_buff_size, &dma_handle,
                                           GFP_KERNEL);
-
                if (pldat->dma_buff_base_v == NULL) {
-                       dev_err(&pdev->dev, "error getting DMA region.\n");
                        ret = -ENOMEM;
                        goto err_out_free_irq;
                }
index 39ab4d09faaa2eb500748466ba6ab0fbe4074ac9..4bdca9ec6a1a9939cc996dd00cbd2853be549965 100644 (file)
@@ -1469,12 +1469,11 @@ 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_alloc_coherent(&pdev->dev, size,
-                                               &rx_ring->rx_buff_pool_logic,
-                                               GFP_KERNEL);
-       if (!rx_ring->rx_buff_pool) {
-               pr_err("Unable to allocate memory for the receive pool buffer\n");
+                                                  &rx_ring->rx_buff_pool_logic,
+                                                  GFP_KERNEL);
+       if (!rx_ring->rx_buff_pool)
                return -ENOMEM;
-       }
+
        memset(rx_ring->rx_buff_pool, 0, size);
        rx_ring->rx_buff_pool_size = size;
        for (i = 0; i < rx_ring->count; i++) {
@@ -1777,7 +1776,6 @@ int pch_gbe_setup_tx_resources(struct pch_gbe_adapter *adapter,
                                           &tx_ring->dma, GFP_KERNEL);
        if (!tx_ring->desc) {
                vfree(tx_ring->buffer_info);
-               pr_err("Unable to allocate memory for the transmit descriptor ring\n");
                return -ENOMEM;
        }
        memset(tx_ring->desc, 0, tx_ring->size);
@@ -1821,9 +1819,7 @@ int pch_gbe_setup_rx_resources(struct pch_gbe_adapter *adapter,
        rx_ring->size = rx_ring->count * (int)sizeof(struct pch_gbe_rx_desc);
        rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,
                                           &rx_ring->dma, GFP_KERNEL);
-
        if (!rx_ring->desc) {
-               pr_err("Unable to allocate memory for the receive descriptor ring\n");
                vfree(rx_ring->buffer_info);
                return -ENOMEM;
        }
index a69097c6b84d4824cc3ed46e982c84fdfd3785c5..a0649ece8e0ac15ff16a4de6d326f5bc8eac569b 100644 (file)
@@ -532,20 +532,15 @@ int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
                ptr = (__le32 *)dma_alloc_coherent(&pdev->dev, sizeof(u32),
                                                   &tx_ring->hw_cons_phys_addr,
                                                   GFP_KERNEL);
-
-               if (ptr == NULL) {
-                       dev_err(&pdev->dev, "failed to allocate tx consumer\n");
+               if (ptr == NULL)
                        return -ENOMEM;
-               }
+
                tx_ring->hw_consumer = ptr;
                /* cmd desc ring */
                addr = dma_alloc_coherent(&pdev->dev, TX_DESC_RINGSIZE(tx_ring),
                                          &tx_ring->phys_addr,
                                          GFP_KERNEL);
-
                if (addr == NULL) {
-                       dev_err(&pdev->dev,
-                               "failed to allocate tx desc ring\n");
                        err = -ENOMEM;
                        goto err_out_free;
                }
@@ -556,11 +551,9 @@ int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
        for (ring = 0; ring < adapter->max_rds_rings; ring++) {
                rds_ring = &recv_ctx->rds_rings[ring];
                addr = dma_alloc_coherent(&adapter->pdev->dev,
-                               RCV_DESC_RINGSIZE(rds_ring),
-                               &rds_ring->phys_addr, GFP_KERNEL);
+                                         RCV_DESC_RINGSIZE(rds_ring),
+                                         &rds_ring->phys_addr, GFP_KERNEL);
                if (addr == NULL) {
-                       dev_err(&pdev->dev,
-                               "failed to allocate rds ring [%d]\n", ring);
                        err = -ENOMEM;
                        goto err_out_free;
                }
@@ -572,11 +565,9 @@ int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
                sds_ring = &recv_ctx->sds_rings[ring];
 
                addr = dma_alloc_coherent(&adapter->pdev->dev,
-                               STATUS_DESC_RINGSIZE(sds_ring),
-                               &sds_ring->phys_addr, GFP_KERNEL);
+                                         STATUS_DESC_RINGSIZE(sds_ring),
+                                         &sds_ring->phys_addr, GFP_KERNEL);
                if (addr == NULL) {
-                       dev_err(&pdev->dev,
-                               "failed to allocate sds ring [%d]\n", ring);
                        err = -ENOMEM;
                        goto err_out_free;
                }
@@ -753,7 +744,7 @@ int qlcnic_82xx_get_nic_info(struct qlcnic_adapter *adapter,
        size_t  nic_size = sizeof(struct qlcnic_info_le);
 
        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
-                               &nic_dma_t, GFP_KERNEL);
+                                          &nic_dma_t, GFP_KERNEL);
        if (!nic_info_addr)
                return -ENOMEM;
        memset(nic_info_addr, 0, nic_size);
@@ -804,7 +795,7 @@ int qlcnic_82xx_set_nic_info(struct qlcnic_adapter *adapter,
                return err;
 
        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
-                       &nic_dma_t, GFP_KERNEL);
+                                          &nic_dma_t, GFP_KERNEL);
        if (!nic_info_addr)
                return -ENOMEM;
 
@@ -949,11 +940,10 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func,
        }
 
        stats_addr = dma_alloc_coherent(&adapter->pdev->dev, stats_size,
-                       &stats_dma_t, GFP_KERNEL);
-       if (!stats_addr) {
-               dev_err(&adapter->pdev->dev, "Unable to allocate memory\n");
+                                       &stats_dma_t, GFP_KERNEL);
+       if (!stats_addr)
                return -ENOMEM;
-       }
+
        memset(stats_addr, 0, stats_size);
 
        arg1 = func | QLCNIC_STATS_VERSION << 8 | QLCNIC_STATS_PORT << 12;
@@ -1003,12 +993,10 @@ int qlcnic_get_mac_stats(struct qlcnic_adapter *adapter,
                return -ENOMEM;
 
        stats_addr = dma_alloc_coherent(&adapter->pdev->dev, stats_size,
-                       &stats_dma_t, GFP_KERNEL);
-       if (!stats_addr) {
-               dev_err(&adapter->pdev->dev,
-                       "%s: Unable to allocate memory.\n", __func__);
+                                       &stats_dma_t, GFP_KERNEL);
+       if (!stats_addr)
                return -ENOMEM;
-       }
+
        memset(stats_addr, 0, stats_size);
        qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_MAC_STATS);
        cmd.req.arg[1] = stats_size << 16;
index abbd22c814a67836a76c43487d62d53b1a6331e8..4b9bab18ebd9b637cbc101e9e7e663cf9d62d709 100644 (file)
@@ -810,11 +810,8 @@ static int __qlcnic_fw_cmd_get_minidump_temp(struct qlcnic_adapter *adapter,
 
        tmp_addr = dma_alloc_coherent(&adapter->pdev->dev, temp_size,
                                      &tmp_addr_t, GFP_KERNEL);
-       if (!tmp_addr) {
-               dev_err(&adapter->pdev->dev,
-                       "Can't get memory for FW dump template\n");
+       if (!tmp_addr)
                return -ENOMEM;
-       }
 
        if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_TEMP_HDR)) {
                err = -ENOMEM;
index 33e96176e4d82167a2d62a51f1f1eb5d711f7375..7a6471d87300121c61adbaca4222b8f0938bbc19 100644 (file)
@@ -908,11 +908,8 @@ static int sh_eth_ring_init(struct net_device *ndev)
        /* Allocate all Rx descriptors. */
        rx_ringsize = sizeof(struct sh_eth_rxdesc) * mdp->num_rx_ring;
        mdp->rx_ring = dma_alloc_coherent(NULL, rx_ringsize, &mdp->rx_desc_dma,
-                       GFP_KERNEL);
-
+                                         GFP_KERNEL);
        if (!mdp->rx_ring) {
-               dev_err(&ndev->dev, "Cannot allocate Rx Ring (size %d bytes)\n",
-                       rx_ringsize);
                ret = -ENOMEM;
                goto desc_ring_free;
        }
@@ -922,10 +919,8 @@ static int sh_eth_ring_init(struct net_device *ndev)
        /* Allocate all Tx descriptors. */
        tx_ringsize = sizeof(struct sh_eth_txdesc) * mdp->num_tx_ring;
        mdp->tx_ring = dma_alloc_coherent(NULL, tx_ringsize, &mdp->tx_desc_dma,
-                       GFP_KERNEL);
+                                         GFP_KERNEL);
        if (!mdp->tx_ring) {
-               dev_err(&ndev->dev, "Cannot allocate Tx Ring (size %d bytes)\n",
-                       tx_ringsize);
                ret = -ENOMEM;
                goto desc_ring_free;
        }
index 39c6c55246331bd4ef9b2d380f213112f8a82072..d02b446037d7b88aca5a239600e1d698a8dc6f13 100644 (file)
@@ -534,25 +534,17 @@ static void init_dma_desc_rings(struct net_device *dev)
                                            GFP_KERNEL);
        priv->rx_skbuff = kmalloc_array(rxsize, sizeof(struct sk_buff *),
                                        GFP_KERNEL);
-       priv->dma_rx =
-           (struct dma_desc *)dma_alloc_coherent(priv->device,
-                                                 rxsize *
-                                                 sizeof(struct dma_desc),
-                                                 &priv->dma_rx_phy,
-                                                 GFP_KERNEL);
+       priv->dma_rx = dma_alloc_coherent(priv->device,
+                                         rxsize * sizeof(struct dma_desc),
+                                         &priv->dma_rx_phy, GFP_KERNEL);
        priv->tx_skbuff = kmalloc_array(txsize, sizeof(struct sk_buff *),
                                        GFP_KERNEL);
-       priv->dma_tx =
-           (struct dma_desc *)dma_alloc_coherent(priv->device,
-                                                 txsize *
-                                                 sizeof(struct dma_desc),
-                                                 &priv->dma_tx_phy,
-                                                 GFP_KERNEL);
-
-       if ((priv->dma_rx == NULL) || (priv->dma_tx == NULL)) {
-               pr_err("%s:ERROR allocating the DMA Tx/Rx desc\n", __func__);
+       priv->dma_tx = dma_alloc_coherent(priv->device,
+                                         txsize * sizeof(struct dma_desc),
+                                         &priv->dma_tx_phy, GFP_KERNEL);
+
+       if ((priv->dma_rx == NULL) || (priv->dma_tx == NULL))
                return;
-       }
 
        DBG(probe, INFO, "stmmac (%s) DMA desc: virt addr (Rx %p, "
            "Tx %p)\n\tDMA phy addr (Rx 0x%08x, Tx 0x%08x)\n",
index 5fafca0653051d3960fc5240341ad0271ffeb832..054975939a184cc48035009420e8d1663871b0f9 100644 (file)
@@ -1169,10 +1169,8 @@ static int bigmac_ether_init(struct platform_device *op,
        bp->bmac_block = dma_alloc_coherent(&bp->bigmac_op->dev,
                                            PAGE_SIZE,
                                            &bp->bblock_dvma, GFP_ATOMIC);
-       if (bp->bmac_block == NULL || bp->bblock_dvma == 0) {
-               printk(KERN_ERR "BIGMAC: Cannot allocate consistent DMA.\n");
+       if (bp->bmac_block == NULL || bp->bblock_dvma == 0)
                goto fail_and_cleanup;
-       }
 
        /* Get the board revision of this BigMAC. */
        bp->board_rev = of_getintprop_default(bp->bigmac_op->dev.of_node,
index a1bff49a815549e862bcaf0d938deb24558d0e54..436fa9d5a07190a555adc6a6b7119700845b2b73 100644 (file)
@@ -2752,10 +2752,8 @@ static int happy_meal_sbus_probe_one(struct platform_device *op, int is_qfe)
                                             &hp->hblock_dvma,
                                             GFP_ATOMIC);
        err = -ENOMEM;
-       if (!hp->happy_block) {
-               printk(KERN_ERR "happymeal: Cannot allocate descriptors.\n");
+       if (!hp->happy_block)
                goto err_out_iounmap;
-       }
 
        /* Force check of the link first time we are brought up. */
        hp->linkcheck = 0;
@@ -3068,14 +3066,11 @@ static int happy_meal_pci_probe(struct pci_dev *pdev,
        hp->happy_bursts = DMA_BURSTBITS;
 #endif
 
-       hp->happy_block = (struct hmeal_init_block *)
-               dma_alloc_coherent(&pdev->dev, PAGE_SIZE, &hp->hblock_dvma, GFP_KERNEL);
-
+       hp->happy_block = dma_alloc_coherent(&pdev->dev, PAGE_SIZE,
+                                            &hp->hblock_dvma, GFP_KERNEL);
        err = -ENODEV;
-       if (!hp->happy_block) {
-               printk(KERN_ERR "happymeal(PCI): Cannot get hme init block.\n");
+       if (!hp->happy_block)
                goto err_out_iounmap;
-       }
 
        hp->linkcheck = 0;
        hp->timer_state = asleep;
index 8fa947a2d9290f2dd7dc612968199aa0f46fdde1..99fe3c6eea31bb4791cc2fd2da1f261148f00e05 100644 (file)
@@ -1309,22 +1309,16 @@ static int tsi108_open(struct net_device *dev)
        }
 
        data->rxring = dma_alloc_coherent(NULL, rxring_size,
-                       &data->rxdma, GFP_KERNEL);
-
+                                         &data->rxdma, GFP_KERNEL);
        if (!data->rxring) {
-               printk(KERN_DEBUG
-                      "TSI108_ETH: failed to allocate memory for rxring!\n");
                return -ENOMEM;
        } else {
                memset(data->rxring, 0, rxring_size);
        }
 
        data->txring = dma_alloc_coherent(NULL, txring_size,
-                       &data->txdma, GFP_KERNEL);
-
+                                         &data->txdma, GFP_KERNEL);
        if (!data->txring) {
-               printk(KERN_DEBUG
-                      "TSI108_ETH: failed to allocate memory for txring!\n");
                pci_free_consistent(0, rxring_size, data->rxring, data->rxdma);
                return -ENOMEM;
        } else {
index 5ac43e4ace25cd223c445bdba41a5b12161691b2..a64a6d74a5c8f9972bf93be6024b588b9ea77a49 100644 (file)
@@ -246,19 +246,14 @@ static int temac_dma_bd_init(struct net_device *ndev)
        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) {
-               dev_err(&ndev->dev,
-                               "unable to allocate DMA TX buffer descriptors");
+       if (!lp->tx_bd_v)
                goto out;
-       }
+
        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) {
-               dev_err(&ndev->dev,
-                               "unable to allocate DMA RX buffer descriptors");
+       if (!lp->rx_bd_v)
                goto out;
-       }
 
        memset(lp->tx_bd_v, 0, sizeof(*lp->tx_bd_v) * TX_BD_NUM);
        for (i = 0; i < TX_BD_NUM; i++) {
index 397d4a6a1f30a89223d9543893c9eb5e99218d74..c238f980e28e8b9a2ab53219dae5bafb13965262 100644 (file)
@@ -205,21 +205,15 @@ static int axienet_dma_bd_init(struct net_device *ndev)
                                         sizeof(*lp->tx_bd_v) * TX_BD_NUM,
                                         &lp->tx_bd_p,
                                         GFP_KERNEL);
-       if (!lp->tx_bd_v) {
-               dev_err(&ndev->dev, "unable to allocate DMA Tx buffer "
-                       "descriptors");
+       if (!lp->tx_bd_v)
                goto out;
-       }
 
        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) {
-               dev_err(&ndev->dev, "unable to allocate DMA Rx buffer "
-                       "descriptors");
+       if (!lp->rx_bd_v)
                goto out;
-       }
 
        memset(lp->tx_bd_v, 0, sizeof(*lp->tx_bd_v) * TX_BD_NUM);
        for (i = 0; i < TX_BD_NUM; i++) {
index 502c8ff1d985b80dd96423040e54fc54dedabaeb..f116e51e3865abf4eebbeb438c82ebcfcf712f5a 100644 (file)
@@ -1071,11 +1071,9 @@ static int dfx_driver_init(struct net_device *dev, const char *print_name,
        bp->kmalloced = top_v = dma_alloc_coherent(bp->bus_dev, alloc_size,
                                                   &bp->kmalloced_dma,
                                                   GFP_ATOMIC);
-       if (top_v == NULL) {
-               printk("%s: Could not allocate memory for host buffers "
-                      "and structures!\n", print_name);
+       if (top_v == NULL)
                return DFX_K_FAILURE;
-       }
+
        memset(top_v, 0, alloc_size);   /* zero out memory before continuing */
        top_p = bp->kmalloced_dma;      /* get physical address of buffer */
 
index fed4a05d55c77bfd520494b5af8fcaaaffbcce39..a06fca61c9a08f308cb0ef82f1d086cf59d0ad33 100644 (file)
@@ -389,7 +389,8 @@ static int bfin_sir_startup(struct bfin_sir_port *port, struct net_device *dev)
        set_dma_callback(port->rx_dma_channel, bfin_sir_dma_rx_int, dev);
        set_dma_callback(port->tx_dma_channel, bfin_sir_dma_tx_int, dev);
 
-       port->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
+       port->rx_dma_buf.buf = dma_alloc_coherent(NULL, PAGE_SIZE,
+                                                 &dma_handle, GFP_DMA);
        port->rx_dma_buf.head = 0;
        port->rx_dma_buf.tail = 0;
        port->rx_dma_nrows = 0;
index 5290952b60c25235f13f308f5041b68795083971..59b45c10adbce11e975c5ef62881a362b328809b 100644 (file)
@@ -564,20 +564,14 @@ static int smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u8 dma,
        self->rx_buff.head =
                dma_alloc_coherent(NULL, self->rx_buff.truesize,
                                   &self->rx_buff_dma, GFP_KERNEL);
-       if (self->rx_buff.head == NULL) {
-               IRDA_ERROR("%s, Can't allocate memory for receive buffer!\n",
-                          driver_name);
+       if (self->rx_buff.head == NULL)
                goto err_out2;
-       }
 
        self->tx_buff.head =
                dma_alloc_coherent(NULL, self->tx_buff.truesize,
                                   &self->tx_buff_dma, GFP_KERNEL);
-       if (self->tx_buff.head == NULL) {
-               IRDA_ERROR("%s, Can't allocate memory for transmit buffer!\n",
-                          driver_name);
+       if (self->tx_buff.head == NULL)
                goto err_out3;
-       }
 
        memset(self->rx_buff.head, 0, self->rx_buff.truesize);
        memset(self->tx_buff.head, 0, self->tx_buff.truesize);
index d1315b442375124d369223bbce0dda98fca8b691..55dd95f9824f2825b136dd66918880439430a965 100644 (file)
@@ -83,8 +83,6 @@ static int wil_vring_alloc(struct wil6210_priv *wil, struct vring *vring)
         */
        vring->va = dma_alloc_coherent(dev, sz, &vring->pa, GFP_KERNEL);
        if (!vring->va) {
-               wil_err(wil, "vring_alloc [%d] failed to alloc DMA mem\n",
-                       vring->size);
                kfree(vring->ctx);
                vring->ctx = NULL;
                return -ENOMEM;
index 2d3c6644f82d9603ac5c18578a4d82c59ce5ac54..07d7e928eac780af879c651f67373b290da6a787 100644 (file)
@@ -335,11 +335,8 @@ static int alloc_ringmemory(struct b43legacy_dmaring *ring)
                                            B43legacy_DMA_RINGMEMSIZE,
                                            &(ring->dmabase),
                                            GFP_KERNEL);
-       if (!ring->descbase) {
-               b43legacyerr(ring->dev->wl, "DMA ringmemory allocation"
-                            " failed\n");
+       if (!ring->descbase)
                return -ENOMEM;
-       }
        memset(ring->descbase, 0, B43legacy_DMA_RINGMEMSIZE);
 
        return 0;
index e0b9d7fa5de0d43d74e130b6c91d4ad0078ecf19..dc1e6da9976af0977ae197475694a8f544ae1643 100644 (file)
@@ -2379,10 +2379,8 @@ il3945_hw_set_hw_params(struct il_priv *il)
        il->_3945.shared_virt =
            dma_alloc_coherent(&il->pci_dev->dev, sizeof(struct il3945_shared),
                               &il->_3945.shared_phys, GFP_KERNEL);
-       if (!il->_3945.shared_virt) {
-               IL_ERR("failed to allocate pci memory\n");
+       if (!il->_3945.shared_virt)
                return -ENOMEM;
-       }
 
        il->hw_params.bcast_id = IL3945_BROADCAST_ID;
 
index e006ea831320ae5a3c3dd15f87a9c00a3eb4d3d8..bd4c18804709488e8f679d4243bfaa2a8a58bb2e 100644 (file)
@@ -2941,10 +2941,9 @@ il_tx_queue_alloc(struct il_priv *il, struct il_tx_queue *txq, u32 id)
         * shared with device */
        txq->tfds =
            dma_alloc_coherent(dev, tfd_sz, &txq->q.dma_addr, GFP_KERNEL);
-       if (!txq->tfds) {
-               IL_ERR("Fail to alloc TFDs\n");
+       if (!txq->tfds)
                goto error;
-       }
+
        txq->q.id = id;
 
        return 0;
index 8595c16f74deb8bdcf531725e3c65c0986d58745..7a508d835f5a106f629bc9dc348aa6e24d8139a2 100644 (file)
@@ -501,10 +501,8 @@ static int iwl_pcie_txq_alloc(struct iwl_trans *trans,
         * shared with device */
        txq->tfds = dma_alloc_coherent(trans->dev, tfd_sz,
                                       &txq->q.dma_addr, GFP_KERNEL);
-       if (!txq->tfds) {
-               IWL_ERR(trans, "dma_alloc_coherent(%zd) failed\n", tfd_sz);
+       if (!txq->tfds)
                goto error;
-       }
 
        BUILD_BUG_ON(IWL_HCMD_SCRATCHBUF_SIZE != sizeof(*txq->scratchbufs));
        BUILD_BUG_ON(offsetof(struct iwl_pcie_txq_scratch_buf, scratch) !=