redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

Merge branch 'topic/dmam' into for-linus

hifive-unleashed-5.1
Vinod Koul 2018-10-24 09:15:43 +01:00
parent edc329fbb8 a436ff1e96
commit b8bb45cbb3
8 changed files with 16 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
drivers/dma/dma-jz4780.c
View File

@ -847,7 +847,7 @@ static int jz4780_dma_probe(struct platform_device *pdev)
jzchan->vchan.desc_free = jz4780_dma_desc_free; jzchan->vchan.desc_free = jz4780_dma_desc_free;
} }
ret = dma_async_device_register(dd); ret = dmaenginem_async_device_register(dd);
if (ret) { if (ret) {
dev_err(dev, "failed to register device\n"); dev_err(dev, "failed to register device\n");
goto err_disable_clk; goto err_disable_clk;
@ -858,15 +858,12 @@ static int jz4780_dma_probe(struct platform_device *pdev)
jzdma); jzdma);
if (ret) { if (ret) {
dev_err(dev, "failed to register OF DMA controller\n"); dev_err(dev, "failed to register OF DMA controller\n");
goto err_unregister_dev; goto err_disable_clk;
} }
dev_info(dev, "JZ4780 DMA controller initialised\n"); dev_info(dev, "JZ4780 DMA controller initialised\n");
return 0; return 0;
err_unregister_dev:
dma_async_device_unregister(dd);
err_disable_clk: err_disable_clk:
clk_disable_unprepare(jzdma->clk); clk_disable_unprepare(jzdma->clk);
@ -887,7 +884,6 @@ static int jz4780_dma_remove(struct platform_device *pdev)
for (i = 0; i < JZ_DMA_NR_CHANNELS; i++) for (i = 0; i < JZ_DMA_NR_CHANNELS; i++)
tasklet_kill(&jzdma->chan[i].vchan.task); tasklet_kill(&jzdma->chan[i].vchan.task);
dma_async_device_unregister(&jzdma->dma_device);
return 0; return 0;
} }

4
drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c
View File

@ -934,7 +934,7 @@ static int dw_probe(struct platform_device *pdev)
pm_runtime_put(chip->dev); pm_runtime_put(chip->dev);
ret = dma_async_device_register(&dw->dma); ret = dmaenginem_async_device_register(&dw->dma);
if (ret) if (ret)
goto err_pm_disable; goto err_pm_disable;
@ -977,8 +977,6 @@ static int dw_remove(struct platform_device *pdev)
tasklet_kill(&chan->vc.task); tasklet_kill(&chan->vc.task);
} }
dma_async_device_unregister(&dw->dma);
return 0; return 0;
} }

7
drivers/dma/mmp_tdma.c
View File

@ -548,9 +548,6 @@ static void mmp_tdma_issue_pending(struct dma_chan *chan)
static int mmp_tdma_remove(struct platform_device *pdev) static int mmp_tdma_remove(struct platform_device *pdev)
{ {
struct mmp_tdma_device *tdev = platform_get_drvdata(pdev);
dma_async_device_unregister(&tdev->device);
return 0; return 0;
} }
@ -714,7 +711,7 @@ static int mmp_tdma_probe(struct platform_device *pdev)
dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)); dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
platform_set_drvdata(pdev, tdev); platform_set_drvdata(pdev, tdev);
ret = dma_async_device_register(&tdev->device); ret = dmaenginem_async_device_register(&tdev->device);
if (ret) { if (ret) {
dev_err(tdev->device.dev, "unable to register\n"); dev_err(tdev->device.dev, "unable to register\n");
return ret; return ret;
@ -726,7 +723,7 @@ static int mmp_tdma_probe(struct platform_device *pdev)
if (ret) { if (ret) {
dev_err(tdev->device.dev, dev_err(tdev->device.dev,
"failed to register controller\n"); "failed to register controller\n");
dma_async_device_unregister(&tdev->device); return ret;
} }
} }

3
drivers/dma/mxs-dma.c
View File

@ -847,7 +847,7 @@ static int __init mxs_dma_probe(struct platform_device *pdev)
mxs_dma->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST; mxs_dma->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
mxs_dma->dma_device.device_issue_pending = mxs_dma_enable_chan; mxs_dma->dma_device.device_issue_pending = mxs_dma_enable_chan;
ret = dma_async_device_register(&mxs_dma->dma_device); ret = dmaenginem_async_device_register(&mxs_dma->dma_device);
if (ret) { if (ret) {
dev_err(mxs_dma->dma_device.dev, "unable to register\n"); dev_err(mxs_dma->dma_device.dev, "unable to register\n");
return ret; return ret;
@ -857,7 +857,6 @@ static int __init mxs_dma_probe(struct platform_device *pdev)
if (ret) { if (ret) {
dev_err(mxs_dma->dma_device.dev, dev_err(mxs_dma->dma_device.dev,
"failed to register controller\n"); "failed to register controller\n");
dma_async_device_unregister(&mxs_dma->dma_device);
} }
dev_info(mxs_dma->dma_device.dev, "initialized\n"); dev_info(mxs_dma->dma_device.dev, "initialized\n");

5
drivers/dma/pxa_dma.c
View File

@ -1285,7 +1285,6 @@ static int pxad_remove(struct platform_device *op)
pxad_cleanup_debugfs(pdev); pxad_cleanup_debugfs(pdev);
pxad_free_channels(&pdev->slave); pxad_free_channels(&pdev->slave);
dma_async_device_unregister(&pdev->slave);
return 0; return 0;
} }
@ -1396,7 +1395,7 @@ static int pxad_init_dmadev(struct platform_device *op,
init_waitqueue_head(&c->wq_state); init_waitqueue_head(&c->wq_state);
} }
return dma_async_device_register(&pdev->slave); return dmaenginem_async_device_register(&pdev->slave);
} }
static int pxad_probe(struct platform_device *op) static int pxad_probe(struct platform_device *op)
@ -1433,7 +1432,7 @@ static int pxad_probe(struct platform_device *op)
"#dma-requests set to default 32 as missing in OF: %d", "#dma-requests set to default 32 as missing in OF: %d",
ret); ret);
nb_requestors = 32; nb_requestors = 32;
}; }
} else if (pdata && pdata->dma_channels) { } else if (pdata && pdata->dma_channels) {
dma_channels = pdata->dma_channels; dma_channels = pdata->dma_channels;
nb_requestors = pdata->nb_requestors; nb_requestors = pdata->nb_requestors;

7
drivers/dma/st_fdma.c
View File

@ -833,7 +833,7 @@ static int st_fdma_probe(struct platform_device *pdev)
fdev->dma_device.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV); fdev->dma_device.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
fdev->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST; fdev->dma_device.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
ret = dma_async_device_register(&fdev->dma_device); ret = dmaenginem_async_device_register(&fdev->dma_device);
if (ret) { if (ret) {
dev_err(&pdev->dev, dev_err(&pdev->dev,
"Failed to register DMA device (%d)\n", ret); "Failed to register DMA device (%d)\n", ret);
@ -844,15 +844,13 @@ static int st_fdma_probe(struct platform_device *pdev)
if (ret) { if (ret) {
dev_err(&pdev->dev, dev_err(&pdev->dev,
"Failed to register controller (%d)\n", ret); "Failed to register controller (%d)\n", ret);
goto err_dma_dev; goto err_rproc;
} }
dev_info(&pdev->dev, "ST FDMA engine driver, irq:%d\n", fdev->irq); dev_info(&pdev->dev, "ST FDMA engine driver, irq:%d\n", fdev->irq);
return 0; return 0;
err_dma_dev:
dma_async_device_unregister(&fdev->dma_device);
err_rproc: err_rproc:
st_fdma_free(fdev); st_fdma_free(fdev);
st_slim_rproc_put(fdev->slim_rproc); st_slim_rproc_put(fdev->slim_rproc);
@ -867,7 +865,6 @@ static int st_fdma_remove(struct platform_device *pdev)
devm_free_irq(&pdev->dev, fdev->irq, fdev); devm_free_irq(&pdev->dev, fdev->irq, fdev);
st_slim_rproc_put(fdev->slim_rproc); st_slim_rproc_put(fdev->slim_rproc);
of_dma_controller_free(pdev->dev.of_node); of_dma_controller_free(pdev->dev.of_node);
dma_async_device_unregister(&fdev->dma_device);
return 0; return 0;
} }

14
drivers/dma/ste_dma40.c
View File

@ -2839,7 +2839,7 @@ static int __init d40_dmaengine_init(struct d40_base *base,
d40_ops_init(base, &base->dma_slave); d40_ops_init(base, &base->dma_slave);
err = dma_async_device_register(&base->dma_slave); err = dmaenginem_async_device_register(&base->dma_slave);
if (err) { if (err) {
d40_err(base->dev, "Failed to register slave channels\n"); d40_err(base->dev, "Failed to register slave channels\n");
@ -2854,12 +2854,12 @@ static int __init d40_dmaengine_init(struct d40_base *base,
d40_ops_init(base, &base->dma_memcpy); d40_ops_init(base, &base->dma_memcpy);
err = dma_async_device_register(&base->dma_memcpy); err = dmaenginem_async_device_register(&base->dma_memcpy);
if (err) { if (err) {
d40_err(base->dev, d40_err(base->dev,
"Failed to register memcpy only channels\n"); "Failed to register memcpy only channels\n");
goto unregister_slave; goto exit;
} }
d40_chan_init(base, &base->dma_both, base->phy_chans, d40_chan_init(base, &base->dma_both, base->phy_chans,
@ -2871,18 +2871,14 @@ static int __init d40_dmaengine_init(struct d40_base *base,
dma_cap_set(DMA_CYCLIC, base->dma_slave.cap_mask); dma_cap_set(DMA_CYCLIC, base->dma_slave.cap_mask);
d40_ops_init(base, &base->dma_both); d40_ops_init(base, &base->dma_both);
err = dma_async_device_register(&base->dma_both); err = dmaenginem_async_device_register(&base->dma_both);
if (err) { if (err) {
d40_err(base->dev, d40_err(base->dev,
"Failed to register logical and physical capable channels\n"); "Failed to register logical and physical capable channels\n");
goto unregister_memcpy; goto exit;
} }
return 0; return 0;
unregister_memcpy:
dma_async_device_unregister(&base->dma_memcpy);
unregister_slave:
dma_async_device_unregister(&base->dma_slave);
exit: exit:
return err; return err;
} }

4
drivers/dma/stm32-mdma.c
View File

@ -1656,7 +1656,7 @@ static int stm32_mdma_probe(struct platform_device *pdev)
return ret; return ret;
} }
ret = dma_async_device_register(dd); ret = dmaenginem_async_device_register(dd);
if (ret) if (ret)
return ret; return ret;
@ -1674,8 +1674,6 @@ static int stm32_mdma_probe(struct platform_device *pdev)
return 0; return 0;
err_unregister: err_unregister:
dma_async_device_unregister(dd);
return ret; return ret;
} }