dmaengine: Remove site specific OOM error messages on kzalloc

If kzalloc() fails it will issue it's own error message including
a dump_stack(). So remove the site specific error messages.

Signed-off-by: Peter Griffin <peter.griffin@linaro.org>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Vinod Koul <vinod.koul@intel.com>

diff --git a/drivers/dma/amba-pl08x.c b/drivers/dma/amba-pl08x.c
index 81db1c4811ceef4f71e8c0c1e5adada3aec07de1..939a7c31f7605928b1a6b1a95591e683f1ab664e 100644 (file)
--- a/drivers/dma/amba-pl08x.c
+++ b/drivers/dma/amba-pl08x.c
@@ -1443,8 +1443,6 @@ static struct dma_async_tx_descriptor *pl08x_prep_dma_memcpy(
        dsg = kzalloc(sizeof(struct pl08x_sg), GFP_NOWAIT);
        if (!dsg) {
                pl08x_free_txd(pl08x, txd);
-               dev_err(&pl08x->adev->dev, "%s no memory for pl080 sg\n",
-                               __func__);
                return NULL;
        }
        list_add_tail(&dsg->node, &txd->dsg_list);
@@ -1901,11 +1899,8 @@ static int pl08x_dma_init_virtual_channels(struct pl08x_driver_data *pl08x,
         */
        for (i = 0; i < channels; i++) {
                chan = kzalloc(sizeof(*chan), GFP_KERNEL);
-               if (!chan) {
-                       dev_err(&pl08x->adev->dev,
-                               "%s no memory for channel\n", __func__);
+               if (!chan)
                        return -ENOMEM;
-               }
 
                chan->host = pl08x;
                chan->state = PL08X_CHAN_IDLE;
@@ -2360,9 +2355,6 @@ static int pl08x_probe(struct amba_device *adev, const struct amba_id *id)
        pl08x->phy_chans = kzalloc((vd->channels * sizeof(*pl08x->phy_chans)),
                        GFP_KERNEL);
        if (!pl08x->phy_chans) {
-               dev_err(&adev->dev, "%s failed to allocate "
-                       "physical channel holders\n",
-                       __func__);
                ret = -ENOMEM;
                goto out_no_phychans;
        }

diff --git a/drivers/dma/bestcomm/bestcomm.c b/drivers/dma/bestcomm/bestcomm.c
index 180fedb418cc1983720072bb6a40b05ff9ea3a82..7ce843723003037495c3af240f20513d1099f6bb 100644 (file)
--- a/drivers/dma/bestcomm/bestcomm.c
+++ b/drivers/dma/bestcomm/bestcomm.c
@@ -397,8 +397,6 @@ static int mpc52xx_bcom_probe(struct platform_device *op)
        /* Get a clean struct */
        bcom_eng = kzalloc(sizeof(struct bcom_engine), GFP_KERNEL);
        if (!bcom_eng) {
-               printk(KERN_ERR DRIVER_NAME ": "
-                       "Can't allocate state structure\n");
                rv = -ENOMEM;
                goto error_sramclean;
        }

diff --git a/drivers/dma/edma.c b/drivers/dma/edma.c
index 8181ed1313865015a169b1e19e44de5ad3df8eb5..3c84cd8215f783e12df674e23f6a7aa3ff509ceb 100644 (file)
--- a/drivers/dma/edma.c
+++ b/drivers/dma/edma.c
@@ -1069,10 +1069,8 @@ static struct dma_async_tx_descriptor *edma_prep_slave_sg(
 
        edesc = kzalloc(sizeof(*edesc) + sg_len * sizeof(edesc->pset[0]),
                        GFP_ATOMIC);
-       if (!edesc) {
-               dev_err(dev, "%s: Failed to allocate a descriptor\n", __func__);
+       if (!edesc)
                return NULL;
-       }
 
        edesc->pset_nr = sg_len;
        edesc->residue = 0;
@@ -1173,10 +1171,8 @@ static struct dma_async_tx_descriptor *edma_prep_dma_memcpy(
 
        edesc = kzalloc(sizeof(*edesc) + nslots * sizeof(edesc->pset[0]),
                        GFP_ATOMIC);
-       if (!edesc) {
-               dev_dbg(dev, "Failed to allocate a descriptor\n");
+       if (!edesc)
                return NULL;
-       }
 
        edesc->pset_nr = nslots;
        edesc->residue = edesc->residue_stat = len;
@@ -1298,10 +1294,8 @@ static struct dma_async_tx_descriptor *edma_prep_dma_cyclic(
 
        edesc = kzalloc(sizeof(*edesc) + nslots * sizeof(edesc->pset[0]),
                        GFP_ATOMIC);
-       if (!edesc) {
-               dev_err(dev, "%s: Failed to allocate a descriptor\n", __func__);
+       if (!edesc)
                return NULL;
-       }
 
        edesc->cyclic = 1;
        edesc->pset_nr = nslots;
@@ -2207,10 +2201,8 @@ static int edma_probe(struct platform_device *pdev)
                return ret;
 
        ecc = devm_kzalloc(dev, sizeof(*ecc), GFP_KERNEL);
-       if (!ecc) {
-               dev_err(dev, "Can't allocate controller\n");
+       if (!ecc)
                return -ENOMEM;
-       }
 
        ecc->dev = dev;
        ecc->id = pdev->id;

diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index a8828ed639b3027c476fc7d82d4d6607221b2ae1..911b7177eb50487dc53269ac705c9c25dc6f8638 100644 (file)
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -1234,7 +1234,6 @@ static int fsl_dma_chan_probe(struct fsldma_device *fdev,
        /* alloc channel */
        chan = kzalloc(sizeof(*chan), GFP_KERNEL);
        if (!chan) {
-               dev_err(fdev->dev, "no free memory for DMA channels!\n");
                err = -ENOMEM;
                goto out_return;
        }
@@ -1340,7 +1339,6 @@ static int fsldma_of_probe(struct platform_device *op)
 
        fdev = kzalloc(sizeof(*fdev), GFP_KERNEL);
        if (!fdev) {
-               dev_err(&op->dev, "No enough memory for 'priv'\n");
                err = -ENOMEM;
                goto out_return;
        }

diff --git a/drivers/dma/k3dma.c b/drivers/dma/k3dma.c
index 1ba2fd73852d273ccf9f8df0e6e6cfc0144fb90d..35961af6e4d7261806134c3144a189680cfc0dd3 100644 (file)
--- a/drivers/dma/k3dma.c
+++ b/drivers/dma/k3dma.c
@@ -425,10 +425,9 @@ static struct dma_async_tx_descriptor *k3_dma_prep_memcpy(
 
        num = DIV_ROUND_UP(len, DMA_MAX_SIZE);
        ds = kzalloc(sizeof(*ds) + num * sizeof(ds->desc_hw[0]), GFP_ATOMIC);
-       if (!ds) {
-               dev_dbg(chan->device->dev, "vchan %p: kzalloc fail\n", &c->vc);
+       if (!ds)
                return NULL;
-       }
+
        ds->desc_hw_lli = __virt_to_phys((unsigned long)&ds->desc_hw[0]);
        ds->size = len;
        ds->desc_num = num;
@@ -481,10 +480,9 @@ static struct dma_async_tx_descriptor *k3_dma_prep_slave_sg(
        }
 
        ds = kzalloc(sizeof(*ds) + num * sizeof(ds->desc_hw[0]), GFP_ATOMIC);
-       if (!ds) {
-               dev_dbg(chan->device->dev, "vchan %p: kzalloc fail\n", &c->vc);
+       if (!ds)
                return NULL;
-       }
+
        ds->desc_hw_lli = __virt_to_phys((unsigned long)&ds->desc_hw[0]);
        ds->desc_num = num;
        num = 0;

diff --git a/drivers/dma/mmp_tdma.c b/drivers/dma/mmp_tdma.c
index 3df0422607d594f995b455782db4f7badced0fc4..ba7f412696c9c05f2bf697dcf54cacf4dd6c8af5 100644 (file)
--- a/drivers/dma/mmp_tdma.c
+++ b/drivers/dma/mmp_tdma.c
@@ -551,10 +551,9 @@ static int mmp_tdma_chan_init(struct mmp_tdma_device *tdev,
 
        /* alloc channel */
        tdmac = devm_kzalloc(tdev->dev, sizeof(*tdmac), GFP_KERNEL);
-       if (!tdmac) {
-               dev_err(tdev->dev, "no free memory for DMA channels!\n");
+       if (!tdmac)
                return -ENOMEM;
-       }
+
        if (irq)
                tdmac->irq = irq;
        tdmac->dev         = tdev->dev;

diff --git a/drivers/dma/moxart-dma.c b/drivers/dma/moxart-dma.c
index 631c4435e075f25d39c6041a523710495d1bfd8d..b3a1d9a22b61d0ad2a8fc75bc9f025f61cdaa43f 100644 (file)
--- a/drivers/dma/moxart-dma.c
+++ b/drivers/dma/moxart-dma.c
@@ -574,10 +574,8 @@ static int moxart_probe(struct platform_device *pdev)
        struct moxart_dmadev *mdc;
 
        mdc = devm_kzalloc(dev, sizeof(*mdc), GFP_KERNEL);
-       if (!mdc) {
-               dev_err(dev, "can't allocate DMA container\n");
+       if (!mdc)
                return -ENOMEM;
-       }
 
        irq = irq_of_parse_and_map(node, 0);
        if (irq == NO_IRQ) {

diff --git a/drivers/dma/nbpfaxi.c b/drivers/dma/nbpfaxi.c
index 2b5a198ac77e483fdf9a0e0479b200935cc4f501..9f0e98b75eb94af70fda3a2e0869a23f85d6f7b9 100644 (file)
--- a/drivers/dma/nbpfaxi.c
+++ b/drivers/dma/nbpfaxi.c
@@ -1300,10 +1300,9 @@ static int nbpf_probe(struct platform_device *pdev)
 
        nbpf = devm_kzalloc(dev, sizeof(*nbpf) + num_channels *
                            sizeof(nbpf->chan[0]), GFP_KERNEL);
-       if (!nbpf) {
-               dev_err(dev, "Memory allocation failed\n");
+       if (!nbpf)
                return -ENOMEM;
-       }
+
        dma_dev = &nbpf->dma_dev;
        dma_dev->dev = dev;
 

diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index 372b4359da97d4d7753233884e65c40abc7261cb..c8767d3e5eb0e8e34e3444e712d9d0c2a9eaf16e 100644 (file)
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -2828,10 +2828,8 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
 
        /* Allocate a new DMAC and its Channels */
        pl330 = devm_kzalloc(&adev->dev, sizeof(*pl330), GFP_KERNEL);
-       if (!pl330) {
-               dev_err(&adev->dev, "unable to allocate mem\n");
+       if (!pl330)
                return -ENOMEM;
-       }
 
        pd = &pl330->ddma;
        pd->dev = &adev->dev;
@@ -2890,7 +2888,6 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
        pl330->peripherals = kzalloc(num_chan * sizeof(*pch), GFP_KERNEL);
        if (!pl330->peripherals) {
                ret = -ENOMEM;
-               dev_err(&adev->dev, "unable to allocate pl330->peripherals\n");
                goto probe_err2;
        }
 

diff --git a/drivers/dma/ppc4xx/adma.c b/drivers/dma/ppc4xx/adma.c
index 9217f893b0d1af7efec3d56bdc281beeb426fcfe..da3688b94bdc1a460c913e5c36aa4cd80838a380 100644 (file)
--- a/drivers/dma/ppc4xx/adma.c
+++ b/drivers/dma/ppc4xx/adma.c
@@ -4084,7 +4084,6 @@ static int ppc440spe_adma_probe(struct platform_device *ofdev)
        /* create a device */
        adev = kzalloc(sizeof(*adev), GFP_KERNEL);
        if (!adev) {
-               dev_err(&ofdev->dev, "failed to allocate device\n");
                initcode = PPC_ADMA_INIT_ALLOC;
                ret = -ENOMEM;
                goto err_adev_alloc;
@@ -4145,7 +4144,6 @@ static int ppc440spe_adma_probe(struct platform_device *ofdev)
        /* create a channel */
        chan = kzalloc(sizeof(*chan), GFP_KERNEL);
        if (!chan) {
-               dev_err(&ofdev->dev, "can't allocate channel structure\n");
                initcode = PPC_ADMA_INIT_CHANNEL;
                ret = -ENOMEM;
                goto err_chan_alloc;

diff --git a/drivers/dma/s3c24xx-dma.c b/drivers/dma/s3c24xx-dma.c
index f7d2c7a0049638225b2b264f406f5fefc409aa76..0d2d187646f4c13ba3f7a0308b421a0fab7890ad 100644 (file)
--- a/drivers/dma/s3c24xx-dma.c
+++ b/drivers/dma/s3c24xx-dma.c
@@ -1101,11 +1101,8 @@ static int s3c24xx_dma_init_virtual_channels(struct s3c24xx_dma_engine *s3cdma,
         */
        for (i = 0; i < channels; i++) {
                chan = devm_kzalloc(dmadev->dev, sizeof(*chan), GFP_KERNEL);
-               if (!chan) {
-                       dev_err(dmadev->dev,
-                               "%s no memory for channel\n", __func__);
+               if (!chan)
                        return -ENOMEM;
-               }
 
                chan->id = i;
                chan->host = s3cdma;

diff --git a/drivers/dma/sh/shdmac.c b/drivers/dma/sh/shdmac.c
index 80d86402490eef39b9873ad3b5a31a39f790973b..c94ffab0d25c756609b1d0c01733a4abc322a8a1 100644 (file)
--- a/drivers/dma/sh/shdmac.c
+++ b/drivers/dma/sh/shdmac.c
@@ -532,11 +532,8 @@ static int sh_dmae_chan_probe(struct sh_dmae_device *shdev, int id,
 
        sh_chan = devm_kzalloc(sdev->dma_dev.dev, sizeof(struct sh_dmae_chan),
                               GFP_KERNEL);
-       if (!sh_chan) {
-               dev_err(sdev->dma_dev.dev,
-                       "No free memory for allocating dma channels!\n");
+       if (!sh_chan)
                return -ENOMEM;
-       }
 
        schan = &sh_chan->shdma_chan;
        schan->max_xfer_len = SH_DMA_TCR_MAX + 1;
@@ -732,10 +729,8 @@ static int sh_dmae_probe(struct platform_device *pdev)
 
        shdev = devm_kzalloc(&pdev->dev, sizeof(struct sh_dmae_device),
                             GFP_KERNEL);
-       if (!shdev) {
-               dev_err(&pdev->dev, "Not enough memory\n");
+       if (!shdev)
                return -ENOMEM;
-       }
 
        dma_dev = &shdev->shdma_dev.dma_dev;
 

diff --git a/drivers/dma/sh/sudmac.c b/drivers/dma/sh/sudmac.c
index 6da2eaa6c294e6018d481f8833ac7c3a379f607e..69b9564dc9d9cb2e68e2c3f9226075e40efd2b8d 100644 (file)
--- a/drivers/dma/sh/sudmac.c
+++ b/drivers/dma/sh/sudmac.c
@@ -245,11 +245,8 @@ static int sudmac_chan_probe(struct sudmac_device *su_dev, int id, int irq,
        int err;
 
        sc = devm_kzalloc(&pdev->dev, sizeof(struct sudmac_chan), GFP_KERNEL);
-       if (!sc) {
-               dev_err(sdev->dma_dev.dev,
-                       "No free memory for allocating dma channels!\n");
+       if (!sc)
                return -ENOMEM;
-       }
 
        schan = &sc->shdma_chan;
        schan->max_xfer_len = 64 * 1024 * 1024 - 1;
@@ -349,10 +346,8 @@ static int sudmac_probe(struct platform_device *pdev)
        err = -ENOMEM;
        su_dev = devm_kzalloc(&pdev->dev, sizeof(struct sudmac_device),
                              GFP_KERNEL);
-       if (!su_dev) {
-               dev_err(&pdev->dev, "Not enough memory\n");
+       if (!su_dev)
                return err;
-       }
 
        dma_dev = &su_dev->shdma_dev.dma_dev;
 

diff --git a/drivers/dma/sirf-dma.c b/drivers/dma/sirf-dma.c
index e48350e650899de4e6e6a90c275d1dd49c6ea582..8ea51c745953a37963e3a0151cfbf02b92b26989 100644 (file)
--- a/drivers/dma/sirf-dma.c
+++ b/drivers/dma/sirf-dma.c
@@ -854,10 +854,9 @@ static int sirfsoc_dma_probe(struct platform_device *op)
        int ret, i;
 
        sdma = devm_kzalloc(dev, sizeof(*sdma), GFP_KERNEL);
-       if (!sdma) {
-               dev_err(dev, "Memory exhausted!\n");
+       if (!sdma)
                return -ENOMEM;
-       }
+
        data = (struct sirfsoc_dmadata *)
                (of_match_device(op->dev.driver->of_match_table,
                                 &op->dev)->data);

diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 378cc47aa63ab6b130a0aeaeaa07e0bfa9c4a57f..8b18e44a02d51438809216a6d1b16e002d60fbde 100644 (file)
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -3237,10 +3237,8 @@ static struct d40_base * __init d40_hw_detect_init(struct platform_device *pdev)
                       (num_phy_chans + num_log_chans + num_memcpy_chans) *
                       sizeof(struct d40_chan), GFP_KERNEL);
 
-       if (base == NULL) {
-               d40_err(&pdev->dev, "Out of memory\n");
+       if (base == NULL)
                goto failure;
-       }
 
        base->rev = rev;
        base->clk = clk;

diff --git a/drivers/dma/tegra20-apb-dma.c b/drivers/dma/tegra20-apb-dma.c
index 7f4af8c5b9d66e3dd647ee0a418d811dceeb19a4..032884fe32770b2cba169e774ee76c4ceb444b35 100644 (file)
--- a/drivers/dma/tegra20-apb-dma.c
+++ b/drivers/dma/tegra20-apb-dma.c
@@ -300,10 +300,8 @@ static struct tegra_dma_desc *tegra_dma_desc_get(
 
        /* Allocate DMA desc */
        dma_desc = kzalloc(sizeof(*dma_desc), GFP_NOWAIT);
-       if (!dma_desc) {
-               dev_err(tdc2dev(tdc), "dma_desc alloc failed\n");
+       if (!dma_desc)
                return NULL;
-       }
 
        dma_async_tx_descriptor_init(&dma_desc->txd, &tdc->dma_chan);
        dma_desc->txd.tx_submit = tegra_dma_tx_submit;
@@ -340,8 +338,7 @@ static struct tegra_dma_sg_req *tegra_dma_sg_req_get(
        spin_unlock_irqrestore(&tdc->lock, flags);
 
        sg_req = kzalloc(sizeof(struct tegra_dma_sg_req), GFP_NOWAIT);
-       if (!sg_req)
-               dev_err(tdc2dev(tdc), "sg_req alloc failed\n");
+
        return sg_req;
 }
 
@@ -1319,10 +1316,8 @@ static int tegra_dma_probe(struct platform_device *pdev)
 
        tdma = devm_kzalloc(&pdev->dev, sizeof(*tdma) + cdata->nr_channels *
                        sizeof(struct tegra_dma_channel), GFP_KERNEL);
-       if (!tdma) {
-               dev_err(&pdev->dev, "Error: memory allocation failed\n");
+       if (!tdma)
                return -ENOMEM;
-       }
 
        tdma->dev = &pdev->dev;
        tdma->chip_data = cdata;

diff --git a/drivers/dma/timb_dma.c b/drivers/dma/timb_dma.c
index 559cd4073698ce806bf448274af6458bdb89ff83..e82745aa42a8bfc5deaecfb62f39d1b2a2972278 100644 (file)
--- a/drivers/dma/timb_dma.c
+++ b/drivers/dma/timb_dma.c
@@ -337,18 +337,14 @@ static struct timb_dma_desc *td_alloc_init_desc(struct timb_dma_chan *td_chan)
        int err;
 
        td_desc = kzalloc(sizeof(struct timb_dma_desc), GFP_KERNEL);
-       if (!td_desc) {
-               dev_err(chan2dev(chan), "Failed to alloc descriptor\n");
+       if (!td_desc)
                goto out;
-       }
 
        td_desc->desc_list_len = td_chan->desc_elems * TIMB_DMA_DESC_SIZE;
 
        td_desc->desc_list = kzalloc(td_desc->desc_list_len, GFP_KERNEL);
-       if (!td_desc->desc_list) {
-               dev_err(chan2dev(chan), "Failed to alloc descriptor\n");
+       if (!td_desc->desc_list)
                goto err;
-       }
 
        dma_async_tx_descriptor_init(&td_desc->txd, chan);
        td_desc->txd.tx_submit = td_tx_submit;