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