Commit | Line | Data |
---|---|---|
a3456a2d RR |
1 | /* |
2 | * sdhci-pltfm.c Support for SDHCI platform devices | |
3 | * Copyright (c) 2009 Intel Corporation | |
4 | * | |
81e49922 | 5 | * Copyright (c) 2007, 2011 Freescale Semiconductor, Inc. |
38576af1 SG |
6 | * Copyright (c) 2009 MontaVista Software, Inc. |
7 | * | |
8 | * Authors: Xiaobo Xie <X.Xie@freescale.com> | |
9 | * Anton Vorontsov <avorontsov@ru.mvista.com> | |
10 | * | |
a3456a2d RR |
11 | * This program is free software; you can redistribute it and/or modify |
12 | * it under the terms of the GNU General Public License version 2 as | |
13 | * published by the Free Software Foundation. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; if not, write to the Free Software | |
22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
23 | */ | |
24 | ||
25 | /* Supports: | |
26 | * SDHCI platform devices | |
27 | * | |
28 | * Inspired by sdhci-pci.c, by Pierre Ossman | |
29 | */ | |
30 | ||
85d6509d | 31 | #include <linux/err.h> |
88b47679 | 32 | #include <linux/module.h> |
38576af1 SG |
33 | #include <linux/of.h> |
34 | #ifdef CONFIG_PPC | |
35 | #include <asm/machdep.h> | |
36 | #endif | |
515033f9 | 37 | #include "sdhci-pltfm.h" |
a3456a2d | 38 | |
d005d943 LPC |
39 | unsigned int sdhci_pltfm_clk_get_max_clock(struct sdhci_host *host) |
40 | { | |
41 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | |
42 | ||
43 | return clk_get_rate(pltfm_host->clk); | |
44 | } | |
45 | EXPORT_SYMBOL_GPL(sdhci_pltfm_clk_get_max_clock); | |
46 | ||
c915568d | 47 | static const struct sdhci_ops sdhci_pltfm_ops = { |
1771059c | 48 | .set_clock = sdhci_set_clock, |
2317f56c | 49 | .set_bus_width = sdhci_set_bus_width, |
03231f9b | 50 | .reset = sdhci_reset, |
96d7b78c | 51 | .set_uhs_signaling = sdhci_set_uhs_signaling, |
a3456a2d RR |
52 | }; |
53 | ||
38576af1 SG |
54 | #ifdef CONFIG_OF |
55 | static bool sdhci_of_wp_inverted(struct device_node *np) | |
56 | { | |
7f217794 AB |
57 | if (of_get_property(np, "sdhci,wp-inverted", NULL) || |
58 | of_get_property(np, "wp-inverted", NULL)) | |
38576af1 SG |
59 | return true; |
60 | ||
61 | /* Old device trees don't have the wp-inverted property. */ | |
62 | #ifdef CONFIG_PPC | |
63 | return machine_is(mpc837x_rdb) || machine_is(mpc837x_mds); | |
64 | #else | |
65 | return false; | |
66 | #endif /* CONFIG_PPC */ | |
67 | } | |
68 | ||
69 | void sdhci_get_of_property(struct platform_device *pdev) | |
70 | { | |
71 | struct device_node *np = pdev->dev.of_node; | |
72 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
73 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | |
74 | const __be32 *clk; | |
7f217794 | 75 | u32 bus_width; |
38576af1 SG |
76 | int size; |
77 | ||
78 | if (of_device_is_available(np)) { | |
79 | if (of_get_property(np, "sdhci,auto-cmd12", NULL)) | |
80 | host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; | |
81 | ||
7f217794 AB |
82 | if (of_get_property(np, "sdhci,1-bit-only", NULL) || |
83 | (of_property_read_u32(np, "bus-width", &bus_width) == 0 && | |
84 | bus_width == 1)) | |
38576af1 SG |
85 | host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA; |
86 | ||
87 | if (sdhci_of_wp_inverted(np)) | |
88 | host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT; | |
89 | ||
38ca7248 CB |
90 | if (of_get_property(np, "broken-cd", NULL)) |
91 | host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; | |
92 | ||
8ed765aa DD |
93 | if (of_get_property(np, "no-1-8-v", NULL)) |
94 | host->quirks2 |= SDHCI_QUIRK2_NO_1_8_V; | |
95 | ||
81e49922 JH |
96 | if (of_device_is_compatible(np, "fsl,p2020-rev1-esdhc")) |
97 | host->quirks |= SDHCI_QUIRK_BROKEN_DMA; | |
98 | ||
147c3b33 JH |
99 | if (of_device_is_compatible(np, "fsl,p2020-esdhc") || |
100 | of_device_is_compatible(np, "fsl,p1010-esdhc") || | |
4590205b | 101 | of_device_is_compatible(np, "fsl,t4240-esdhc") || |
147c3b33 JH |
102 | of_device_is_compatible(np, "fsl,mpc8536-esdhc")) |
103 | host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL; | |
104 | ||
38576af1 SG |
105 | clk = of_get_property(np, "clock-frequency", &size); |
106 | if (clk && size == sizeof(*clk) && *clk) | |
107 | pltfm_host->clock = be32_to_cpup(clk); | |
f5ccfd41 AK |
108 | |
109 | if (of_find_property(np, "keep-power-in-suspend", NULL)) | |
110 | host->mmc->pm_caps |= MMC_PM_KEEP_POWER; | |
111 | ||
112 | if (of_find_property(np, "enable-sdio-wakeup", NULL)) | |
113 | host->mmc->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; | |
38576af1 SG |
114 | } |
115 | } | |
116 | #else | |
117 | void sdhci_get_of_property(struct platform_device *pdev) {} | |
118 | #endif /* CONFIG_OF */ | |
f0de8369 | 119 | EXPORT_SYMBOL_GPL(sdhci_get_of_property); |
38576af1 | 120 | |
85d6509d | 121 | struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev, |
0e748234 CD |
122 | const struct sdhci_pltfm_data *pdata, |
123 | size_t priv_size) | |
a3456a2d RR |
124 | { |
125 | struct sdhci_host *host; | |
a4d2177f | 126 | struct device_node *np = pdev->dev.of_node; |
a3456a2d RR |
127 | struct resource *iomem; |
128 | int ret; | |
129 | ||
a3456a2d RR |
130 | iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
131 | if (!iomem) { | |
132 | ret = -ENOMEM; | |
133 | goto err; | |
134 | } | |
135 | ||
e632c45a | 136 | if (resource_size(iomem) < 0x100) |
85d6509d | 137 | dev_err(&pdev->dev, "Invalid iomem size!\n"); |
a3456a2d | 138 | |
4b711cb1 | 139 | /* Some PCI-based MFD need the parent here */ |
a4d2177f | 140 | if (pdev->dev.parent != &platform_bus && !np) |
0e748234 CD |
141 | host = sdhci_alloc_host(pdev->dev.parent, |
142 | sizeof(struct sdhci_pltfm_host) + priv_size); | |
a3456a2d | 143 | else |
0e748234 CD |
144 | host = sdhci_alloc_host(&pdev->dev, |
145 | sizeof(struct sdhci_pltfm_host) + priv_size); | |
a3456a2d RR |
146 | |
147 | if (IS_ERR(host)) { | |
148 | ret = PTR_ERR(host); | |
149 | goto err; | |
150 | } | |
151 | ||
85d6509d | 152 | host->hw_name = dev_name(&pdev->dev); |
a7626b7a AV |
153 | if (pdata && pdata->ops) |
154 | host->ops = pdata->ops; | |
155 | else | |
156 | host->ops = &sdhci_pltfm_ops; | |
ad82ab65 | 157 | if (pdata) { |
a7626b7a | 158 | host->quirks = pdata->quirks; |
ad82ab65 AC |
159 | host->quirks2 = pdata->quirks2; |
160 | } | |
161 | ||
a3456a2d RR |
162 | host->irq = platform_get_irq(pdev, 0); |
163 | ||
164 | if (!request_mem_region(iomem->start, resource_size(iomem), | |
165 | mmc_hostname(host->mmc))) { | |
166 | dev_err(&pdev->dev, "cannot request region\n"); | |
167 | ret = -EBUSY; | |
168 | goto err_request; | |
169 | } | |
170 | ||
171 | host->ioaddr = ioremap(iomem->start, resource_size(iomem)); | |
172 | if (!host->ioaddr) { | |
173 | dev_err(&pdev->dev, "failed to remap registers\n"); | |
174 | ret = -ENOMEM; | |
175 | goto err_remap; | |
176 | } | |
177 | ||
63ef5d8c JH |
178 | /* |
179 | * Some platforms need to probe the controller to be able to | |
180 | * determine which caps should be used. | |
181 | */ | |
182 | if (host->ops && host->ops->platform_init) | |
183 | host->ops->platform_init(host); | |
184 | ||
a3456a2d RR |
185 | platform_set_drvdata(pdev, host); |
186 | ||
85d6509d | 187 | return host; |
a3456a2d | 188 | |
a3456a2d RR |
189 | err_remap: |
190 | release_mem_region(iomem->start, resource_size(iomem)); | |
191 | err_request: | |
192 | sdhci_free_host(host); | |
193 | err: | |
85d6509d SG |
194 | dev_err(&pdev->dev, "%s failed %d\n", __func__, ret); |
195 | return ERR_PTR(ret); | |
a3456a2d | 196 | } |
f0de8369 | 197 | EXPORT_SYMBOL_GPL(sdhci_pltfm_init); |
a3456a2d | 198 | |
85d6509d | 199 | void sdhci_pltfm_free(struct platform_device *pdev) |
a3456a2d RR |
200 | { |
201 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
202 | struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
a3456a2d | 203 | |
a3456a2d RR |
204 | iounmap(host->ioaddr); |
205 | release_mem_region(iomem->start, resource_size(iomem)); | |
206 | sdhci_free_host(host); | |
85d6509d | 207 | } |
f0de8369 | 208 | EXPORT_SYMBOL_GPL(sdhci_pltfm_free); |
a3456a2d | 209 | |
85d6509d | 210 | int sdhci_pltfm_register(struct platform_device *pdev, |
0e748234 CD |
211 | const struct sdhci_pltfm_data *pdata, |
212 | size_t priv_size) | |
85d6509d SG |
213 | { |
214 | struct sdhci_host *host; | |
215 | int ret = 0; | |
216 | ||
0e748234 | 217 | host = sdhci_pltfm_init(pdev, pdata, priv_size); |
85d6509d SG |
218 | if (IS_ERR(host)) |
219 | return PTR_ERR(host); | |
220 | ||
38576af1 SG |
221 | sdhci_get_of_property(pdev); |
222 | ||
85d6509d SG |
223 | ret = sdhci_add_host(host); |
224 | if (ret) | |
225 | sdhci_pltfm_free(pdev); | |
226 | ||
227 | return ret; | |
a3456a2d | 228 | } |
f0de8369 | 229 | EXPORT_SYMBOL_GPL(sdhci_pltfm_register); |
a3456a2d | 230 | |
85d6509d SG |
231 | int sdhci_pltfm_unregister(struct platform_device *pdev) |
232 | { | |
233 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
234 | int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff); | |
235 | ||
236 | sdhci_remove_host(host, dead); | |
237 | sdhci_pltfm_free(pdev); | |
238 | ||
239 | return 0; | |
240 | } | |
f0de8369 | 241 | EXPORT_SYMBOL_GPL(sdhci_pltfm_unregister); |
515033f9 | 242 | |
be8ae09d | 243 | #ifdef CONFIG_PM |
d433dc63 | 244 | int sdhci_pltfm_suspend(struct device *dev) |
be8ae09d | 245 | { |
29495aa0 | 246 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d | 247 | |
29495aa0 | 248 | return sdhci_suspend_host(host); |
be8ae09d | 249 | } |
d433dc63 | 250 | EXPORT_SYMBOL_GPL(sdhci_pltfm_suspend); |
be8ae09d | 251 | |
d433dc63 | 252 | int sdhci_pltfm_resume(struct device *dev) |
be8ae09d | 253 | { |
29495aa0 | 254 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d GC |
255 | |
256 | return sdhci_resume_host(host); | |
257 | } | |
d433dc63 | 258 | EXPORT_SYMBOL_GPL(sdhci_pltfm_resume); |
29495aa0 ML |
259 | |
260 | const struct dev_pm_ops sdhci_pltfm_pmops = { | |
261 | .suspend = sdhci_pltfm_suspend, | |
262 | .resume = sdhci_pltfm_resume, | |
263 | }; | |
264 | EXPORT_SYMBOL_GPL(sdhci_pltfm_pmops); | |
be8ae09d | 265 | #endif /* CONFIG_PM */ |
f0de8369 SG |
266 | |
267 | static int __init sdhci_pltfm_drv_init(void) | |
268 | { | |
269 | pr_info("sdhci-pltfm: SDHCI platform and OF driver helper\n"); | |
270 | ||
271 | return 0; | |
272 | } | |
273 | module_init(sdhci_pltfm_drv_init); | |
274 | ||
275 | static void __exit sdhci_pltfm_drv_exit(void) | |
276 | { | |
277 | } | |
278 | module_exit(sdhci_pltfm_drv_exit); | |
279 | ||
280 | MODULE_DESCRIPTION("SDHCI platform and OF driver helper"); | |
281 | MODULE_AUTHOR("Intel Corporation"); | |
282 | MODULE_LICENSE("GPL v2"); |