platform.c (b685fe26e9af7318d73bf50af659a282d188a3e5) platform.c (f5e84eae7956c694d27ddaba7113fe7d1174eff7)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Platform driver for the Synopsys DesignWare DMA Controller
4 *
5 * Copyright (C) 2007-2008 Atmel Corporation
6 * Copyright (C) 2010-2011 ST Microelectronics
7 * Copyright (C) 2013 Intel Corporation
8 *
9 * Some parts of this driver are derived from the original dw_dmac.
10 */
11
12#include <linux/module.h>
13#include <linux/device.h>
14#include <linux/clk.h>
15#include <linux/pm_runtime.h>
16#include <linux/platform_device.h>
17#include <linux/dmaengine.h>
18#include <linux/dma-mapping.h>
19#include <linux/of.h>
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Platform driver for the Synopsys DesignWare DMA Controller
4 *
5 * Copyright (C) 2007-2008 Atmel Corporation
6 * Copyright (C) 2010-2011 ST Microelectronics
7 * Copyright (C) 2013 Intel Corporation
8 *
9 * Some parts of this driver are derived from the original dw_dmac.
10 */
11
12#include <linux/module.h>
13#include <linux/device.h>
14#include <linux/clk.h>
15#include <linux/pm_runtime.h>
16#include <linux/platform_device.h>
17#include <linux/dmaengine.h>
18#include <linux/dma-mapping.h>
19#include <linux/of.h>
20#include <linux/of_dma.h>
21#include <linux/acpi.h>
22
23#include "internal.h"
24
25#define DRV_NAME "dw_dmac"
26
20#include <linux/acpi.h>
21
22#include "internal.h"
23
24#define DRV_NAME "dw_dmac"
25
27static struct dma_chan *dw_dma_of_xlate(struct of_phandle_args *dma_spec,
28 struct of_dma *ofdma)
29{
30 struct dw_dma *dw = ofdma->of_dma_data;
31 struct dw_dma_slave slave = {
32 .dma_dev = dw->dma.dev,
33 };
34 dma_cap_mask_t cap;
35
36 if (dma_spec->args_count != 3)
37 return NULL;
38
39 slave.src_id = dma_spec->args[0];
40 slave.dst_id = dma_spec->args[0];
41 slave.m_master = dma_spec->args[1];
42 slave.p_master = dma_spec->args[2];
43
44 if (WARN_ON(slave.src_id >= DW_DMA_MAX_NR_REQUESTS ||
45 slave.dst_id >= DW_DMA_MAX_NR_REQUESTS ||
46 slave.m_master >= dw->pdata->nr_masters ||
47 slave.p_master >= dw->pdata->nr_masters))
48 return NULL;
49
50 dma_cap_zero(cap);
51 dma_cap_set(DMA_SLAVE, cap);
52
53 /* TODO: there should be a simpler way to do this */
54 return dma_request_channel(cap, dw_dma_filter, &slave);
55}
56
57#ifdef CONFIG_OF
58static struct dw_dma_platform_data *
59dw_dma_parse_dt(struct platform_device *pdev)
60{
61 struct device_node *np = pdev->dev.of_node;
62 struct dw_dma_platform_data *pdata;
63 u32 tmp, arr[DW_DMA_MAX_NR_MASTERS], mb[DW_DMA_MAX_NR_CHANNELS];
64 u32 nr_masters;
65 u32 nr_channels;
66
67 if (!np) {
68 dev_err(&pdev->dev, "Missing DT data\n");
69 return NULL;
70 }
71
72 if (of_property_read_u32(np, "dma-masters", &nr_masters))
73 return NULL;
74 if (nr_masters < 1 || nr_masters > DW_DMA_MAX_NR_MASTERS)
75 return NULL;
76
77 if (of_property_read_u32(np, "dma-channels", &nr_channels))
78 return NULL;
79 if (nr_channels > DW_DMA_MAX_NR_CHANNELS)
80 return NULL;
81
82 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
83 if (!pdata)
84 return NULL;
85
86 pdata->nr_masters = nr_masters;
87 pdata->nr_channels = nr_channels;
88
89 if (!of_property_read_u32(np, "chan_allocation_order", &tmp))
90 pdata->chan_allocation_order = (unsigned char)tmp;
91
92 if (!of_property_read_u32(np, "chan_priority", &tmp))
93 pdata->chan_priority = tmp;
94
95 if (!of_property_read_u32(np, "block_size", &tmp))
96 pdata->block_size = tmp;
97
98 if (!of_property_read_u32_array(np, "data-width", arr, nr_masters)) {
99 for (tmp = 0; tmp < nr_masters; tmp++)
100 pdata->data_width[tmp] = arr[tmp];
101 } else if (!of_property_read_u32_array(np, "data_width", arr, nr_masters)) {
102 for (tmp = 0; tmp < nr_masters; tmp++)
103 pdata->data_width[tmp] = BIT(arr[tmp] & 0x07);
104 }
105
106 if (!of_property_read_u32_array(np, "multi-block", mb, nr_channels)) {
107 for (tmp = 0; tmp < nr_channels; tmp++)
108 pdata->multi_block[tmp] = mb[tmp];
109 } else {
110 for (tmp = 0; tmp < nr_channels; tmp++)
111 pdata->multi_block[tmp] = 1;
112 }
113
114 if (!of_property_read_u32(np, "snps,dma-protection-control", &tmp)) {
115 if (tmp > CHAN_PROTCTL_MASK)
116 return NULL;
117 pdata->protctl = tmp;
118 }
119
120 return pdata;
121}
122#else
123static inline struct dw_dma_platform_data *
124dw_dma_parse_dt(struct platform_device *pdev)
125{
126 return NULL;
127}
128#endif
129
130static int dw_probe(struct platform_device *pdev)
131{
132 const struct dw_dma_chip_pdata *match;
133 struct dw_dma_chip_pdata *data;
134 struct dw_dma_chip *chip;
135 struct device *dev = &pdev->dev;
136 int err;
137

--- 42 unchanged lines hidden (view full) ---

180 pm_runtime_enable(&pdev->dev);
181
182 err = data->probe(chip);
183 if (err)
184 goto err_dw_dma_probe;
185
186 platform_set_drvdata(pdev, data);
187
26static int dw_probe(struct platform_device *pdev)
27{
28 const struct dw_dma_chip_pdata *match;
29 struct dw_dma_chip_pdata *data;
30 struct dw_dma_chip *chip;
31 struct device *dev = &pdev->dev;
32 int err;
33

--- 42 unchanged lines hidden (view full) ---

76 pm_runtime_enable(&pdev->dev);
77
78 err = data->probe(chip);
79 if (err)
80 goto err_dw_dma_probe;
81
82 platform_set_drvdata(pdev, data);
83
188 if (pdev->dev.of_node) {
189 err = of_dma_controller_register(pdev->dev.of_node,
190 dw_dma_of_xlate, chip->dw);
191 if (err)
192 dev_err(&pdev->dev,
193 "could not register of_dma_controller\n");
194 }
84 dw_dma_of_controller_register(chip->dw);
195
196 dw_dma_acpi_controller_register(chip->dw);
197
198 return 0;
199
200err_dw_dma_probe:
201 pm_runtime_disable(&pdev->dev);
202 clk_disable_unprepare(chip->clk);
203 return err;
204}
205
206static int dw_remove(struct platform_device *pdev)
207{
208 struct dw_dma_chip_pdata *data = platform_get_drvdata(pdev);
209 struct dw_dma_chip *chip = data->chip;
210 int ret;
211
212 dw_dma_acpi_controller_free(chip->dw);
213
85
86 dw_dma_acpi_controller_register(chip->dw);
87
88 return 0;
89
90err_dw_dma_probe:
91 pm_runtime_disable(&pdev->dev);
92 clk_disable_unprepare(chip->clk);
93 return err;
94}
95
96static int dw_remove(struct platform_device *pdev)
97{
98 struct dw_dma_chip_pdata *data = platform_get_drvdata(pdev);
99 struct dw_dma_chip *chip = data->chip;
100 int ret;
101
102 dw_dma_acpi_controller_free(chip->dw);
103
214 if (pdev->dev.of_node)
215 of_dma_controller_free(pdev->dev.of_node);
104 dw_dma_of_controller_free(chip->dw);
216
217 ret = data->remove(chip);
218 if (ret)
219 dev_warn(chip->dev, "can't remove device properly: %d\n", ret);
220
221 pm_runtime_disable(&pdev->dev);
222 clk_disable_unprepare(chip->clk);
223

--- 107 unchanged lines hidden --- 		105
106 ret = data->remove(chip);
107 if (ret)
108 dev_warn(chip->dev, "can't remove device properly: %d\n", ret);
109
110 pm_runtime_disable(&pdev->dev);
111 clk_disable_unprepare(chip->clk);
112

--- 107 unchanged lines hidden ---