1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 #include <linux/acpi.h>
4 #include <linux/clk.h>
5 #include <linux/device.h>
6 #include <linux/err.h>
7 #include <linux/init.h>
8 #include <linux/mod_devicetable.h>
9 #include <linux/platform_device.h>
10 #include <linux/pm_runtime.h>
11 #include <linux/property.h>
12 #include <linux/types.h>
13
14 #include "spi-pxa2xx.h"
15
pxa2xx_spi_idma_filter(struct dma_chan * chan,void * param)16 static bool pxa2xx_spi_idma_filter(struct dma_chan *chan, void *param)
17 {
18 return param == chan->device->dev;
19 }
20
21 static int
pxa2xx_spi_init_ssp(struct platform_device * pdev,struct ssp_device * ssp,enum pxa_ssp_type type)22 pxa2xx_spi_init_ssp(struct platform_device *pdev, struct ssp_device *ssp, enum pxa_ssp_type type)
23 {
24 struct device *dev = &pdev->dev;
25 struct resource *res;
26 int status;
27 u64 uid;
28
29 ssp->mmio_base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
30 if (IS_ERR(ssp->mmio_base))
31 return PTR_ERR(ssp->mmio_base);
32
33 ssp->phys_base = res->start;
34
35 ssp->clk = devm_clk_get(dev, NULL);
36 if (IS_ERR(ssp->clk))
37 return PTR_ERR(ssp->clk);
38
39 ssp->irq = platform_get_irq(pdev, 0);
40 if (ssp->irq < 0)
41 return ssp->irq;
42
43 ssp->type = type;
44 ssp->dev = dev;
45
46 status = acpi_dev_uid_to_integer(ACPI_COMPANION(dev), &uid);
47 if (status)
48 ssp->port_id = -1;
49 else
50 ssp->port_id = uid;
51
52 return 0;
53 }
54
pxa2xx_spi_ssp_release(void * ssp)55 static void pxa2xx_spi_ssp_release(void *ssp)
56 {
57 pxa_ssp_free(ssp);
58 }
59
pxa2xx_spi_ssp_request(struct platform_device * pdev)60 static struct ssp_device *pxa2xx_spi_ssp_request(struct platform_device *pdev)
61 {
62 struct ssp_device *ssp;
63 int status;
64
65 ssp = pxa_ssp_request(pdev->id, pdev->name);
66 if (!ssp)
67 return NULL;
68
69 status = devm_add_action_or_reset(&pdev->dev, pxa2xx_spi_ssp_release, ssp);
70 if (status)
71 return ERR_PTR(status);
72
73 return ssp;
74 }
75
76 static struct pxa2xx_spi_controller *
pxa2xx_spi_init_pdata(struct platform_device * pdev)77 pxa2xx_spi_init_pdata(struct platform_device *pdev)
78 {
79 struct pxa2xx_spi_controller *pdata;
80 struct device *dev = &pdev->dev;
81 struct device *parent = dev->parent;
82 const void *match = device_get_match_data(dev);
83 enum pxa_ssp_type type = SSP_UNDEFINED;
84 struct ssp_device *ssp;
85 bool is_lpss_priv;
86 u32 num_cs = 1;
87 int status;
88
89 ssp = pxa2xx_spi_ssp_request(pdev);
90 if (IS_ERR(ssp))
91 return ERR_CAST(ssp);
92 if (ssp) {
93 type = ssp->type;
94 } else if (match) {
95 type = (enum pxa_ssp_type)(uintptr_t)match;
96 } else {
97 u32 value;
98
99 status = device_property_read_u32(dev, "intel,spi-pxa2xx-type", &value);
100 if (status)
101 return ERR_PTR(status);
102
103 type = (enum pxa_ssp_type)value;
104 }
105
106 /* Validate the SSP type correctness */
107 if (!(type > SSP_UNDEFINED && type < SSP_MAX))
108 return ERR_PTR(-EINVAL);
109
110 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
111 if (!pdata)
112 return ERR_PTR(-ENOMEM);
113
114 /* Platforms with iDMA 64-bit */
115 is_lpss_priv = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpss_priv");
116 if (is_lpss_priv) {
117 pdata->tx_param = parent;
118 pdata->rx_param = parent;
119 pdata->dma_filter = pxa2xx_spi_idma_filter;
120 }
121
122 /* Read number of chip select pins, if provided */
123 device_property_read_u32(dev, "num-cs", &num_cs);
124
125 pdata->num_chipselect = num_cs;
126 pdata->is_target = device_property_read_bool(dev, "spi-slave");
127 pdata->enable_dma = true;
128 pdata->dma_burst_size = 1;
129
130 /* If SSP has been already enumerated, use it */
131 if (ssp)
132 return pdata;
133
134 status = pxa2xx_spi_init_ssp(pdev, &pdata->ssp, type);
135 if (status)
136 return ERR_PTR(status);
137
138 return pdata;
139 }
140
pxa2xx_spi_platform_probe(struct platform_device * pdev)141 static int pxa2xx_spi_platform_probe(struct platform_device *pdev)
142 {
143 struct pxa2xx_spi_controller *platform_info;
144 struct device *dev = &pdev->dev;
145 struct ssp_device *ssp;
146 int ret;
147
148 platform_info = dev_get_platdata(dev);
149 if (!platform_info) {
150 platform_info = pxa2xx_spi_init_pdata(pdev);
151 if (IS_ERR(platform_info))
152 return dev_err_probe(dev, PTR_ERR(platform_info), "missing platform data\n");
153 }
154
155 ssp = pxa2xx_spi_ssp_request(pdev);
156 if (IS_ERR(ssp))
157 return PTR_ERR(ssp);
158 if (!ssp)
159 ssp = &platform_info->ssp;
160
161 pm_runtime_set_autosuspend_delay(dev, 50);
162 pm_runtime_use_autosuspend(dev);
163 pm_runtime_set_active(dev);
164 pm_runtime_enable(dev);
165
166 ret = pxa2xx_spi_probe(dev, ssp, platform_info);
167 if (ret)
168 pm_runtime_disable(dev);
169
170 return ret;
171 }
172
pxa2xx_spi_platform_remove(struct platform_device * pdev)173 static void pxa2xx_spi_platform_remove(struct platform_device *pdev)
174 {
175 struct device *dev = &pdev->dev;
176
177 pm_runtime_get_sync(dev);
178
179 pxa2xx_spi_remove(dev);
180
181 pm_runtime_put_noidle(dev);
182 pm_runtime_disable(dev);
183 }
184
185 static const struct acpi_device_id pxa2xx_spi_acpi_match[] = {
186 { "80860F0E" },
187 { "8086228E" },
188 { "INT33C0" },
189 { "INT33C1" },
190 { "INT3430" },
191 { "INT3431" },
192 {}
193 };
194 MODULE_DEVICE_TABLE(acpi, pxa2xx_spi_acpi_match);
195
196 static const struct of_device_id pxa2xx_spi_of_match[] = {
197 { .compatible = "marvell,mmp2-ssp", .data = (void *)MMP2_SSP },
198 {}
199 };
200 MODULE_DEVICE_TABLE(of, pxa2xx_spi_of_match);
201
202 static struct platform_driver driver = {
203 .driver = {
204 .name = "pxa2xx-spi",
205 .pm = pm_ptr(&pxa2xx_spi_pm_ops),
206 .acpi_match_table = pxa2xx_spi_acpi_match,
207 .of_match_table = pxa2xx_spi_of_match,
208 },
209 .probe = pxa2xx_spi_platform_probe,
210 .remove_new = pxa2xx_spi_platform_remove,
211 };
212
pxa2xx_spi_init(void)213 static int __init pxa2xx_spi_init(void)
214 {
215 return platform_driver_register(&driver);
216 }
217 subsys_initcall(pxa2xx_spi_init);
218
pxa2xx_spi_exit(void)219 static void __exit pxa2xx_spi_exit(void)
220 {
221 platform_driver_unregister(&driver);
222 }
223 module_exit(pxa2xx_spi_exit);
224
225 MODULE_AUTHOR("Stephen Street");
226 MODULE_DESCRIPTION("PXA2xx SSP SPI Controller platform driver");
227 MODULE_LICENSE("GPL");
228 MODULE_IMPORT_NS(SPI_PXA2xx);
229 MODULE_ALIAS("platform:pxa2xx-spi");
230 MODULE_SOFTDEP("pre: dw_dmac");
231