2 * Platform driver for the Synopsys DesignWare DMA Controller
4 * Copyright (C) 2007-2008 Atmel Corporation
5 * Copyright (C) 2010-2011 ST Microelectronics
6 * Copyright (C) 2013 Intel Corporation
8 * Some parts of this driver are derived from the original dw_dmac.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/module.h>
16 #include <linux/device.h>
17 #include <linux/clk.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/platform_device.h>
20 #include <linux/dmaengine.h>
21 #include <linux/dma-mapping.h>
23 #include <linux/of_dma.h>
24 #include <linux/acpi.h>
25 #include <linux/acpi_dma.h>
29 static struct dma_chan
*dw_dma_of_xlate(struct of_phandle_args
*dma_spec
,
32 struct dw_dma
*dw
= ofdma
->of_dma_data
;
33 struct dw_dma_slave slave
= {
34 .dma_dev
= dw
->dma
.dev
,
38 if (dma_spec
->args_count
!= 3)
41 slave
.src_id
= dma_spec
->args
[0];
42 slave
.dst_id
= dma_spec
->args
[0];
43 slave
.src_master
= dma_spec
->args
[1];
44 slave
.dst_master
= dma_spec
->args
[2];
46 if (WARN_ON(slave
.src_id
>= DW_DMA_MAX_NR_REQUESTS
||
47 slave
.dst_id
>= DW_DMA_MAX_NR_REQUESTS
||
48 slave
.src_master
>= dw
->nr_masters
||
49 slave
.dst_master
>= dw
->nr_masters
))
53 dma_cap_set(DMA_SLAVE
, cap
);
55 /* TODO: there should be a simpler way to do this */
56 return dma_request_channel(cap
, dw_dma_filter
, &slave
);
60 static bool dw_dma_acpi_filter(struct dma_chan
*chan
, void *param
)
62 struct acpi_dma_spec
*dma_spec
= param
;
63 struct dw_dma_slave slave
= {
64 .dma_dev
= dma_spec
->dev
,
65 .src_id
= dma_spec
->slave_id
,
66 .dst_id
= dma_spec
->slave_id
,
71 return dw_dma_filter(chan
, &slave
);
74 static void dw_dma_acpi_controller_register(struct dw_dma
*dw
)
76 struct device
*dev
= dw
->dma
.dev
;
77 struct acpi_dma_filter_info
*info
;
80 info
= devm_kzalloc(dev
, sizeof(*info
), GFP_KERNEL
);
84 dma_cap_zero(info
->dma_cap
);
85 dma_cap_set(DMA_SLAVE
, info
->dma_cap
);
86 info
->filter_fn
= dw_dma_acpi_filter
;
88 ret
= devm_acpi_dma_controller_register(dev
, acpi_dma_simple_xlate
,
91 dev_err(dev
, "could not register acpi_dma_controller\n");
93 #else /* !CONFIG_ACPI */
94 static inline void dw_dma_acpi_controller_register(struct dw_dma
*dw
) {}
95 #endif /* !CONFIG_ACPI */
98 static struct dw_dma_platform_data
*
99 dw_dma_parse_dt(struct platform_device
*pdev
)
101 struct device_node
*np
= pdev
->dev
.of_node
;
102 struct dw_dma_platform_data
*pdata
;
106 dev_err(&pdev
->dev
, "Missing DT data\n");
110 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
114 if (of_property_read_u32(np
, "dma-channels", &pdata
->nr_channels
))
117 if (of_property_read_bool(np
, "is_private"))
118 pdata
->is_private
= true;
120 if (!of_property_read_u32(np
, "chan_allocation_order", &tmp
))
121 pdata
->chan_allocation_order
= (unsigned char)tmp
;
123 if (!of_property_read_u32(np
, "chan_priority", &tmp
))
124 pdata
->chan_priority
= tmp
;
126 if (!of_property_read_u32(np
, "block_size", &tmp
))
127 pdata
->block_size
= tmp
;
129 if (!of_property_read_u32(np
, "dma-masters", &tmp
)) {
133 pdata
->nr_masters
= tmp
;
136 if (!of_property_read_u32_array(np
, "data_width", arr
,
138 for (tmp
= 0; tmp
< pdata
->nr_masters
; tmp
++)
139 pdata
->data_width
[tmp
] = arr
[tmp
];
144 static inline struct dw_dma_platform_data
*
145 dw_dma_parse_dt(struct platform_device
*pdev
)
151 static int dw_probe(struct platform_device
*pdev
)
153 struct dw_dma_chip
*chip
;
154 struct device
*dev
= &pdev
->dev
;
155 struct resource
*mem
;
156 struct dw_dma_platform_data
*pdata
;
159 chip
= devm_kzalloc(dev
, sizeof(*chip
), GFP_KERNEL
);
163 chip
->irq
= platform_get_irq(pdev
, 0);
167 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
168 chip
->regs
= devm_ioremap_resource(dev
, mem
);
169 if (IS_ERR(chip
->regs
))
170 return PTR_ERR(chip
->regs
);
172 err
= dma_coerce_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(32));
176 pdata
= dev_get_platdata(dev
);
178 pdata
= dw_dma_parse_dt(pdev
);
182 chip
->clk
= devm_clk_get(chip
->dev
, "hclk");
183 if (IS_ERR(chip
->clk
))
184 return PTR_ERR(chip
->clk
);
185 err
= clk_prepare_enable(chip
->clk
);
189 pm_runtime_enable(&pdev
->dev
);
191 err
= dw_dma_probe(chip
, pdata
);
193 goto err_dw_dma_probe
;
195 platform_set_drvdata(pdev
, chip
);
197 if (pdev
->dev
.of_node
) {
198 err
= of_dma_controller_register(pdev
->dev
.of_node
,
199 dw_dma_of_xlate
, chip
->dw
);
202 "could not register of_dma_controller\n");
205 if (ACPI_HANDLE(&pdev
->dev
))
206 dw_dma_acpi_controller_register(chip
->dw
);
211 pm_runtime_disable(&pdev
->dev
);
212 clk_disable_unprepare(chip
->clk
);
216 static int dw_remove(struct platform_device
*pdev
)
218 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
220 if (pdev
->dev
.of_node
)
221 of_dma_controller_free(pdev
->dev
.of_node
);
224 pm_runtime_disable(&pdev
->dev
);
225 clk_disable_unprepare(chip
->clk
);
230 static void dw_shutdown(struct platform_device
*pdev
)
232 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
234 dw_dma_disable(chip
);
235 clk_disable_unprepare(chip
->clk
);
239 static const struct of_device_id dw_dma_of_id_table
[] = {
240 { .compatible
= "snps,dma-spear1340" },
243 MODULE_DEVICE_TABLE(of
, dw_dma_of_id_table
);
247 static const struct acpi_device_id dw_dma_acpi_id_table
[] = {
251 MODULE_DEVICE_TABLE(acpi
, dw_dma_acpi_id_table
);
254 #ifdef CONFIG_PM_SLEEP
256 static int dw_suspend_late(struct device
*dev
)
258 struct platform_device
*pdev
= to_platform_device(dev
);
259 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
261 dw_dma_disable(chip
);
262 clk_disable_unprepare(chip
->clk
);
267 static int dw_resume_early(struct device
*dev
)
269 struct platform_device
*pdev
= to_platform_device(dev
);
270 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
272 clk_prepare_enable(chip
->clk
);
273 return dw_dma_enable(chip
);
276 #endif /* CONFIG_PM_SLEEP */
278 static const struct dev_pm_ops dw_dev_pm_ops
= {
279 SET_LATE_SYSTEM_SLEEP_PM_OPS(dw_suspend_late
, dw_resume_early
)
282 static struct platform_driver dw_driver
= {
285 .shutdown
= dw_shutdown
,
288 .pm
= &dw_dev_pm_ops
,
289 .of_match_table
= of_match_ptr(dw_dma_of_id_table
),
290 .acpi_match_table
= ACPI_PTR(dw_dma_acpi_id_table
),
294 static int __init
dw_init(void)
296 return platform_driver_register(&dw_driver
);
298 subsys_initcall(dw_init
);
300 static void __exit
dw_exit(void)
302 platform_driver_unregister(&dw_driver
);
304 module_exit(dw_exit
);
306 MODULE_LICENSE("GPL v2");
307 MODULE_DESCRIPTION("Synopsys DesignWare DMA Controller platform driver");