niansa-misc/linux
1
0
Fork 0
mirror of synced 2025-03-06 20:59:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

dmaengine: stm32-dma: Add PM Runtime support

Browse source 
Use pm_runtime engine for clock management purpose.

Signed-off-by: Pierre-Yves MORDRET <pierre-yves.mordret@st.com>
Signed-off-by: Vinod Koul <vkoul@kernel.org>
This commit is contained in:
Pierre-Yves MORDRET 2019-01-03 11:17:08 +01:00 • committed by Vinod Koul
parent ca4c72c01e
commit 48bc73ba14
1 changed files with 51 additions and 7 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
drivers/dma/stm32-dma.c
View file

@ -23,6 +23,7 @@
#include <linux/of_device.h> #include <linux/of_device.h>
#include <linux/of_dma.h> #include <linux/of_dma.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/reset.h> #include <linux/reset.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/slab.h> #include <linux/slab.h>
@ -1115,15 +1116,14 @@ static int stm32_dma_alloc_chan_resources(struct dma_chan *c)
int ret; int ret;
chan->config_init = false; chan->config_init = false;
ret = clk_prepare_enable(dmadev->clk);
if (ret < 0) { ret = pm_runtime_get_sync(dmadev->ddev.dev);
dev_err(chan2dev(chan), "clk_prepare_enable failed: %d\n", ret); if (ret < 0)
return ret; return ret;
}
ret = stm32_dma_disable_chan(chan); ret = stm32_dma_disable_chan(chan);
if (ret < 0) if (ret < 0)
clk_disable_unprepare(dmadev->clk); pm_runtime_put(dmadev->ddev.dev);
return ret; return ret;
} }
@ -1143,7 +1143,7 @@ static void stm32_dma_free_chan_resources(struct dma_chan *c)
spin_unlock_irqrestore(&chan->vchan.lock, flags); spin_unlock_irqrestore(&chan->vchan.lock, flags);
} }
clk_disable_unprepare(dmadev->clk); pm_runtime_put(dmadev->ddev.dev);
vchan_free_chan_resources(to_virt_chan(c)); vchan_free_chan_resources(to_virt_chan(c));
} }
@ -1243,6 +1243,12 @@ static int stm32_dma_probe(struct platform_device *pdev)
return PTR_ERR(dmadev->clk); return PTR_ERR(dmadev->clk);
} }
ret = clk_prepare_enable(dmadev->clk);
if (ret < 0) {
dev_err(&pdev->dev, "clk_prep_enable error: %d\n", ret);
return ret;
}
dmadev->mem2mem = of_property_read_bool(pdev->dev.of_node, dmadev->mem2mem = of_property_read_bool(pdev->dev.of_node,
"st,mem2mem"); "st,mem2mem");
@ -1292,7 +1298,7 @@ static int stm32_dma_probe(struct platform_device *pdev)
ret = dma_async_device_register(dd); ret = dma_async_device_register(dd);
if (ret) if (ret)
return ret; goto clk_free;
for (i = 0; i < STM32_DMA_MAX_CHANNELS; i++) { for (i = 0; i < STM32_DMA_MAX_CHANNELS; i++) {
chan = &dmadev->chan[i]; chan = &dmadev->chan[i];
@ -1324,20 +1330,58 @@ static int stm32_dma_probe(struct platform_device *pdev)
platform_set_drvdata(pdev, dmadev); platform_set_drvdata(pdev, dmadev);
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
pm_runtime_put(&pdev->dev);
dev_info(&pdev->dev, "STM32 DMA driver registered\n"); dev_info(&pdev->dev, "STM32 DMA driver registered\n");
return 0; return 0;
err_unregister: err_unregister:
dma_async_device_unregister(dd); dma_async_device_unregister(dd);
clk_free:
clk_disable_unprepare(dmadev->clk);
return ret; return ret;
} }
#ifdef CONFIG_PM
static int stm32_dma_runtime_suspend(struct device *dev)
{
struct stm32_dma_device *dmadev = dev_get_drvdata(dev);
clk_disable_unprepare(dmadev->clk);
return 0;
}
static int stm32_dma_runtime_resume(struct device *dev)
{
struct stm32_dma_device *dmadev = dev_get_drvdata(dev);
int ret;
ret = clk_prepare_enable(dmadev->clk);
if (ret) {
dev_err(dev, "failed to prepare_enable clock\n");
return ret;
}
return 0;
}
#endif
static const struct dev_pm_ops stm32_dma_pm_ops = {
SET_RUNTIME_PM_OPS(stm32_dma_runtime_suspend,
stm32_dma_runtime_resume, NULL)
};
static struct platform_driver stm32_dma_driver = { static struct platform_driver stm32_dma_driver = {
.driver = { .driver = {
.name = "stm32-dma", .name = "stm32-dma",
.of_match_table = stm32_dma_of_match, .of_match_table = stm32_dma_of_match,
.pm = &stm32_dma_pm_ops,
}, },
}; };