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/platform_device.h>
19 #include <linux/dmaengine.h>
20 #include <linux/dma-mapping.h>
22 #include <linux/of_dma.h>
23 #include <linux/acpi.h>
24 #include <linux/acpi_dma.h>
28 static struct dma_chan
*dw_dma_of_xlate(struct of_phandle_args
*dma_spec
,
31 struct dw_dma
*dw
= ofdma
->of_dma_data
;
32 struct dw_dma_slave slave
= {
33 .dma_dev
= dw
->dma
.dev
,
37 if (dma_spec
->args_count
!= 3)
40 slave
.src_id
= dma_spec
->args
[0];
41 slave
.dst_id
= dma_spec
->args
[0];
42 slave
.src_master
= dma_spec
->args
[1];
43 slave
.dst_master
= dma_spec
->args
[2];
45 if (WARN_ON(slave
.src_id
>= DW_DMA_MAX_NR_REQUESTS
||
46 slave
.dst_id
>= DW_DMA_MAX_NR_REQUESTS
||
47 slave
.src_master
>= dw
->nr_masters
||
48 slave
.dst_master
>= dw
->nr_masters
))
52 dma_cap_set(DMA_SLAVE
, cap
);
54 /* TODO: there should be a simpler way to do this */
55 return dma_request_channel(cap
, dw_dma_filter
, &slave
);
59 static bool dw_dma_acpi_filter(struct dma_chan
*chan
, void *param
)
61 struct acpi_dma_spec
*dma_spec
= param
;
62 struct dw_dma_slave slave
= {
63 .dma_dev
= dma_spec
->dev
,
64 .src_id
= dma_spec
->slave_id
,
65 .dst_id
= dma_spec
->slave_id
,
70 return dw_dma_filter(chan
, &slave
);
73 static void dw_dma_acpi_controller_register(struct dw_dma
*dw
)
75 struct device
*dev
= dw
->dma
.dev
;
76 struct acpi_dma_filter_info
*info
;
79 info
= devm_kzalloc(dev
, sizeof(*info
), GFP_KERNEL
);
83 dma_cap_zero(info
->dma_cap
);
84 dma_cap_set(DMA_SLAVE
, info
->dma_cap
);
85 info
->filter_fn
= dw_dma_acpi_filter
;
87 ret
= devm_acpi_dma_controller_register(dev
, acpi_dma_simple_xlate
,
90 dev_err(dev
, "could not register acpi_dma_controller\n");
92 #else /* !CONFIG_ACPI */
93 static inline void dw_dma_acpi_controller_register(struct dw_dma
*dw
) {}
94 #endif /* !CONFIG_ACPI */
97 static struct dw_dma_platform_data
*
98 dw_dma_parse_dt(struct platform_device
*pdev
)
100 struct device_node
*np
= pdev
->dev
.of_node
;
101 struct dw_dma_platform_data
*pdata
;
105 dev_err(&pdev
->dev
, "Missing DT data\n");
109 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
113 if (of_property_read_u32(np
, "dma-channels", &pdata
->nr_channels
))
116 if (of_property_read_bool(np
, "is_private"))
117 pdata
->is_private
= true;
119 if (!of_property_read_u32(np
, "chan_allocation_order", &tmp
))
120 pdata
->chan_allocation_order
= (unsigned char)tmp
;
122 if (!of_property_read_u32(np
, "chan_priority", &tmp
))
123 pdata
->chan_priority
= tmp
;
125 if (!of_property_read_u32(np
, "block_size", &tmp
))
126 pdata
->block_size
= tmp
;
128 if (!of_property_read_u32(np
, "dma-masters", &tmp
)) {
132 pdata
->nr_masters
= tmp
;
135 if (!of_property_read_u32_array(np
, "data_width", arr
,
137 for (tmp
= 0; tmp
< pdata
->nr_masters
; tmp
++)
138 pdata
->data_width
[tmp
] = arr
[tmp
];
143 static inline struct dw_dma_platform_data
*
144 dw_dma_parse_dt(struct platform_device
*pdev
)
150 static int dw_probe(struct platform_device
*pdev
)
152 struct dw_dma_chip
*chip
;
153 struct device
*dev
= &pdev
->dev
;
154 struct resource
*mem
;
155 struct dw_dma_platform_data
*pdata
;
158 chip
= devm_kzalloc(dev
, sizeof(*chip
), GFP_KERNEL
);
162 chip
->irq
= platform_get_irq(pdev
, 0);
166 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
167 chip
->regs
= devm_ioremap_resource(dev
, mem
);
168 if (IS_ERR(chip
->regs
))
169 return PTR_ERR(chip
->regs
);
171 err
= dma_coerce_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(32));
175 pdata
= dev_get_platdata(dev
);
177 pdata
= dw_dma_parse_dt(pdev
);
181 chip
->clk
= devm_clk_get(chip
->dev
, "hclk");
182 if (IS_ERR(chip
->clk
))
183 return PTR_ERR(chip
->clk
);
184 err
= clk_prepare_enable(chip
->clk
);
188 err
= dw_dma_probe(chip
, pdata
);
190 goto err_dw_dma_probe
;
192 platform_set_drvdata(pdev
, chip
);
194 if (pdev
->dev
.of_node
) {
195 err
= of_dma_controller_register(pdev
->dev
.of_node
,
196 dw_dma_of_xlate
, chip
->dw
);
199 "could not register of_dma_controller\n");
202 if (ACPI_HANDLE(&pdev
->dev
))
203 dw_dma_acpi_controller_register(chip
->dw
);
208 clk_disable_unprepare(chip
->clk
);
212 static int dw_remove(struct platform_device
*pdev
)
214 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
216 if (pdev
->dev
.of_node
)
217 of_dma_controller_free(pdev
->dev
.of_node
);
220 clk_disable_unprepare(chip
->clk
);
225 static void dw_shutdown(struct platform_device
*pdev
)
227 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
229 dw_dma_disable(chip
);
230 clk_disable_unprepare(chip
->clk
);
234 static const struct of_device_id dw_dma_of_id_table
[] = {
235 { .compatible
= "snps,dma-spear1340" },
238 MODULE_DEVICE_TABLE(of
, dw_dma_of_id_table
);
242 static const struct acpi_device_id dw_dma_acpi_id_table
[] = {
246 MODULE_DEVICE_TABLE(acpi
, dw_dma_acpi_id_table
);
249 #ifdef CONFIG_PM_SLEEP
251 static int dw_suspend_late(struct device
*dev
)
253 struct platform_device
*pdev
= to_platform_device(dev
);
254 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
256 dw_dma_disable(chip
);
257 clk_disable_unprepare(chip
->clk
);
262 static int dw_resume_early(struct device
*dev
)
264 struct platform_device
*pdev
= to_platform_device(dev
);
265 struct dw_dma_chip
*chip
= platform_get_drvdata(pdev
);
267 clk_prepare_enable(chip
->clk
);
268 return dw_dma_enable(chip
);
271 #endif /* CONFIG_PM_SLEEP */
273 static const struct dev_pm_ops dw_dev_pm_ops
= {
274 SET_LATE_SYSTEM_SLEEP_PM_OPS(dw_suspend_late
, dw_resume_early
)
277 static struct platform_driver dw_driver
= {
280 .shutdown
= dw_shutdown
,
283 .pm
= &dw_dev_pm_ops
,
284 .of_match_table
= of_match_ptr(dw_dma_of_id_table
),
285 .acpi_match_table
= ACPI_PTR(dw_dma_acpi_id_table
),
289 static int __init
dw_init(void)
291 return platform_driver_register(&dw_driver
);
293 subsys_initcall(dw_init
);
295 static void __exit
dw_exit(void)
297 platform_driver_unregister(&dw_driver
);
299 module_exit(dw_exit
);
301 MODULE_LICENSE("GPL v2");
302 MODULE_DESCRIPTION("Synopsys DesignWare DMA Controller platform driver");