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 | |
a3456a2d RR |
39 | static struct sdhci_ops sdhci_pltfm_ops = { |
40 | }; | |
41 | ||
38576af1 SG |
42 | #ifdef CONFIG_OF |
43 | static bool sdhci_of_wp_inverted(struct device_node *np) | |
44 | { | |
7f217794 AB |
45 | if (of_get_property(np, "sdhci,wp-inverted", NULL) || |
46 | of_get_property(np, "wp-inverted", NULL)) | |
38576af1 SG |
47 | return true; |
48 | ||
49 | /* Old device trees don't have the wp-inverted property. */ | |
50 | #ifdef CONFIG_PPC | |
51 | return machine_is(mpc837x_rdb) || machine_is(mpc837x_mds); | |
52 | #else | |
53 | return false; | |
54 | #endif /* CONFIG_PPC */ | |
55 | } | |
56 | ||
57 | void sdhci_get_of_property(struct platform_device *pdev) | |
58 | { | |
59 | struct device_node *np = pdev->dev.of_node; | |
60 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
61 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | |
62 | const __be32 *clk; | |
7f217794 | 63 | u32 bus_width; |
38576af1 SG |
64 | int size; |
65 | ||
66 | if (of_device_is_available(np)) { | |
67 | if (of_get_property(np, "sdhci,auto-cmd12", NULL)) | |
68 | host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; | |
69 | ||
7f217794 AB |
70 | if (of_get_property(np, "sdhci,1-bit-only", NULL) || |
71 | (of_property_read_u32(np, "bus-width", &bus_width) == 0 && | |
72 | bus_width == 1)) | |
38576af1 SG |
73 | host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA; |
74 | ||
75 | if (sdhci_of_wp_inverted(np)) | |
76 | host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT; | |
77 | ||
38ca7248 CB |
78 | if (of_get_property(np, "broken-cd", NULL)) |
79 | host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; | |
80 | ||
8ed765aa DD |
81 | if (of_get_property(np, "no-1-8-v", NULL)) |
82 | host->quirks2 |= SDHCI_QUIRK2_NO_1_8_V; | |
83 | ||
81e49922 JH |
84 | if (of_device_is_compatible(np, "fsl,p2020-rev1-esdhc")) |
85 | host->quirks |= SDHCI_QUIRK_BROKEN_DMA; | |
86 | ||
147c3b33 JH |
87 | if (of_device_is_compatible(np, "fsl,p2020-esdhc") || |
88 | of_device_is_compatible(np, "fsl,p1010-esdhc") || | |
89 | of_device_is_compatible(np, "fsl,mpc8536-esdhc")) | |
90 | host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL; | |
91 | ||
38576af1 SG |
92 | clk = of_get_property(np, "clock-frequency", &size); |
93 | if (clk && size == sizeof(*clk) && *clk) | |
94 | pltfm_host->clock = be32_to_cpup(clk); | |
f5ccfd41 AK |
95 | |
96 | if (of_find_property(np, "keep-power-in-suspend", NULL)) | |
97 | host->mmc->pm_caps |= MMC_PM_KEEP_POWER; | |
98 | ||
99 | if (of_find_property(np, "enable-sdio-wakeup", NULL)) | |
100 | host->mmc->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; | |
38576af1 SG |
101 | } |
102 | } | |
103 | #else | |
104 | void sdhci_get_of_property(struct platform_device *pdev) {} | |
105 | #endif /* CONFIG_OF */ | |
f0de8369 | 106 | EXPORT_SYMBOL_GPL(sdhci_get_of_property); |
38576af1 | 107 | |
85d6509d SG |
108 | struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev, |
109 | struct sdhci_pltfm_data *pdata) | |
a3456a2d RR |
110 | { |
111 | struct sdhci_host *host; | |
4b711cb1 | 112 | struct sdhci_pltfm_host *pltfm_host; |
a4d2177f | 113 | struct device_node *np = pdev->dev.of_node; |
a3456a2d RR |
114 | struct resource *iomem; |
115 | int ret; | |
116 | ||
a3456a2d RR |
117 | iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
118 | if (!iomem) { | |
119 | ret = -ENOMEM; | |
120 | goto err; | |
121 | } | |
122 | ||
e632c45a | 123 | if (resource_size(iomem) < 0x100) |
85d6509d | 124 | dev_err(&pdev->dev, "Invalid iomem size!\n"); |
a3456a2d | 125 | |
4b711cb1 | 126 | /* Some PCI-based MFD need the parent here */ |
a4d2177f | 127 | if (pdev->dev.parent != &platform_bus && !np) |
4b711cb1 | 128 | host = sdhci_alloc_host(pdev->dev.parent, sizeof(*pltfm_host)); |
a3456a2d | 129 | else |
4b711cb1 | 130 | host = sdhci_alloc_host(&pdev->dev, sizeof(*pltfm_host)); |
a3456a2d RR |
131 | |
132 | if (IS_ERR(host)) { | |
133 | ret = PTR_ERR(host); | |
134 | goto err; | |
135 | } | |
136 | ||
4b711cb1 WS |
137 | pltfm_host = sdhci_priv(host); |
138 | ||
85d6509d | 139 | host->hw_name = dev_name(&pdev->dev); |
a7626b7a AV |
140 | if (pdata && pdata->ops) |
141 | host->ops = pdata->ops; | |
142 | else | |
143 | host->ops = &sdhci_pltfm_ops; | |
144 | if (pdata) | |
145 | host->quirks = pdata->quirks; | |
a3456a2d RR |
146 | host->irq = platform_get_irq(pdev, 0); |
147 | ||
148 | if (!request_mem_region(iomem->start, resource_size(iomem), | |
149 | mmc_hostname(host->mmc))) { | |
150 | dev_err(&pdev->dev, "cannot request region\n"); | |
151 | ret = -EBUSY; | |
152 | goto err_request; | |
153 | } | |
154 | ||
155 | host->ioaddr = ioremap(iomem->start, resource_size(iomem)); | |
156 | if (!host->ioaddr) { | |
157 | dev_err(&pdev->dev, "failed to remap registers\n"); | |
158 | ret = -ENOMEM; | |
159 | goto err_remap; | |
160 | } | |
161 | ||
63ef5d8c JH |
162 | /* |
163 | * Some platforms need to probe the controller to be able to | |
164 | * determine which caps should be used. | |
165 | */ | |
166 | if (host->ops && host->ops->platform_init) | |
167 | host->ops->platform_init(host); | |
168 | ||
a3456a2d RR |
169 | platform_set_drvdata(pdev, host); |
170 | ||
85d6509d | 171 | return host; |
a3456a2d | 172 | |
a3456a2d RR |
173 | err_remap: |
174 | release_mem_region(iomem->start, resource_size(iomem)); | |
175 | err_request: | |
176 | sdhci_free_host(host); | |
177 | err: | |
85d6509d SG |
178 | dev_err(&pdev->dev, "%s failed %d\n", __func__, ret); |
179 | return ERR_PTR(ret); | |
a3456a2d | 180 | } |
f0de8369 | 181 | EXPORT_SYMBOL_GPL(sdhci_pltfm_init); |
a3456a2d | 182 | |
85d6509d | 183 | void sdhci_pltfm_free(struct platform_device *pdev) |
a3456a2d RR |
184 | { |
185 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
186 | struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
a3456a2d | 187 | |
a3456a2d RR |
188 | iounmap(host->ioaddr); |
189 | release_mem_region(iomem->start, resource_size(iomem)); | |
190 | sdhci_free_host(host); | |
191 | platform_set_drvdata(pdev, NULL); | |
85d6509d | 192 | } |
f0de8369 | 193 | EXPORT_SYMBOL_GPL(sdhci_pltfm_free); |
a3456a2d | 194 | |
85d6509d SG |
195 | int sdhci_pltfm_register(struct platform_device *pdev, |
196 | struct sdhci_pltfm_data *pdata) | |
197 | { | |
198 | struct sdhci_host *host; | |
199 | int ret = 0; | |
200 | ||
201 | host = sdhci_pltfm_init(pdev, pdata); | |
202 | if (IS_ERR(host)) | |
203 | return PTR_ERR(host); | |
204 | ||
38576af1 SG |
205 | sdhci_get_of_property(pdev); |
206 | ||
85d6509d SG |
207 | ret = sdhci_add_host(host); |
208 | if (ret) | |
209 | sdhci_pltfm_free(pdev); | |
210 | ||
211 | return ret; | |
a3456a2d | 212 | } |
f0de8369 | 213 | EXPORT_SYMBOL_GPL(sdhci_pltfm_register); |
a3456a2d | 214 | |
85d6509d SG |
215 | int sdhci_pltfm_unregister(struct platform_device *pdev) |
216 | { | |
217 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
218 | int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff); | |
219 | ||
220 | sdhci_remove_host(host, dead); | |
221 | sdhci_pltfm_free(pdev); | |
222 | ||
223 | return 0; | |
224 | } | |
f0de8369 | 225 | EXPORT_SYMBOL_GPL(sdhci_pltfm_unregister); |
515033f9 | 226 | |
be8ae09d | 227 | #ifdef CONFIG_PM |
29495aa0 | 228 | static int sdhci_pltfm_suspend(struct device *dev) |
be8ae09d | 229 | { |
29495aa0 | 230 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d | 231 | |
29495aa0 | 232 | return sdhci_suspend_host(host); |
be8ae09d GC |
233 | } |
234 | ||
29495aa0 | 235 | static int sdhci_pltfm_resume(struct device *dev) |
be8ae09d | 236 | { |
29495aa0 | 237 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d GC |
238 | |
239 | return sdhci_resume_host(host); | |
240 | } | |
29495aa0 ML |
241 | |
242 | const struct dev_pm_ops sdhci_pltfm_pmops = { | |
243 | .suspend = sdhci_pltfm_suspend, | |
244 | .resume = sdhci_pltfm_resume, | |
245 | }; | |
246 | EXPORT_SYMBOL_GPL(sdhci_pltfm_pmops); | |
be8ae09d | 247 | #endif /* CONFIG_PM */ |
f0de8369 SG |
248 | |
249 | static int __init sdhci_pltfm_drv_init(void) | |
250 | { | |
251 | pr_info("sdhci-pltfm: SDHCI platform and OF driver helper\n"); | |
252 | ||
253 | return 0; | |
254 | } | |
255 | module_init(sdhci_pltfm_drv_init); | |
256 | ||
257 | static void __exit sdhci_pltfm_drv_exit(void) | |
258 | { | |
259 | } | |
260 | module_exit(sdhci_pltfm_drv_exit); | |
261 | ||
262 | MODULE_DESCRIPTION("SDHCI platform and OF driver helper"); | |
263 | MODULE_AUTHOR("Intel Corporation"); | |
264 | MODULE_LICENSE("GPL v2"); |