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); | |
7f217794 | 74 | u32 bus_width; |
38576af1 | 75 | |
5ec35820 KH |
76 | if (of_get_property(np, "sdhci,auto-cmd12", NULL)) |
77 | host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; | |
38576af1 | 78 | |
5ec35820 KH |
79 | if (of_get_property(np, "sdhci,1-bit-only", NULL) || |
80 | (of_property_read_u32(np, "bus-width", &bus_width) == 0 && | |
81 | bus_width == 1)) | |
82 | host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA; | |
38576af1 | 83 | |
5ec35820 KH |
84 | if (sdhci_of_wp_inverted(np)) |
85 | host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT; | |
38576af1 | 86 | |
5ec35820 KH |
87 | if (of_get_property(np, "broken-cd", NULL)) |
88 | host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; | |
38ca7248 | 89 | |
5ec35820 KH |
90 | if (of_get_property(np, "no-1-8-v", NULL)) |
91 | host->quirks2 |= SDHCI_QUIRK2_NO_1_8_V; | |
8ed765aa | 92 | |
5ec35820 KH |
93 | if (of_device_is_compatible(np, "fsl,p2020-rev1-esdhc")) |
94 | host->quirks |= SDHCI_QUIRK_BROKEN_DMA; | |
81e49922 | 95 | |
5ec35820 KH |
96 | if (of_device_is_compatible(np, "fsl,p2020-esdhc") || |
97 | of_device_is_compatible(np, "fsl,p1010-esdhc") || | |
98 | of_device_is_compatible(np, "fsl,t4240-esdhc") || | |
99 | of_device_is_compatible(np, "fsl,mpc8536-esdhc")) | |
100 | host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL; | |
147c3b33 | 101 | |
e02b9d7c | 102 | of_property_read_u32(np, "clock-frequency", &pltfm_host->clock); |
f5ccfd41 | 103 | |
5ec35820 KH |
104 | if (of_find_property(np, "keep-power-in-suspend", NULL)) |
105 | host->mmc->pm_caps |= MMC_PM_KEEP_POWER; | |
f5ccfd41 | 106 | |
0dbcdc06 SH |
107 | if (of_property_read_bool(np, "wakeup-source") || |
108 | of_property_read_bool(np, "enable-sdio-wakeup")) /* legacy */ | |
5ec35820 | 109 | host->mmc->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; |
38576af1 SG |
110 | } |
111 | #else | |
112 | void sdhci_get_of_property(struct platform_device *pdev) {} | |
113 | #endif /* CONFIG_OF */ | |
f0de8369 | 114 | EXPORT_SYMBOL_GPL(sdhci_get_of_property); |
38576af1 | 115 | |
85d6509d | 116 | struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev, |
0e748234 CD |
117 | const struct sdhci_pltfm_data *pdata, |
118 | size_t priv_size) | |
a3456a2d RR |
119 | { |
120 | struct sdhci_host *host; | |
121 | struct resource *iomem; | |
122 | int ret; | |
123 | ||
a3456a2d RR |
124 | iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
125 | if (!iomem) { | |
126 | ret = -ENOMEM; | |
127 | goto err; | |
128 | } | |
129 | ||
45c19e2a PM |
130 | host = sdhci_alloc_host(&pdev->dev, |
131 | sizeof(struct sdhci_pltfm_host) + priv_size); | |
a3456a2d RR |
132 | |
133 | if (IS_ERR(host)) { | |
134 | ret = PTR_ERR(host); | |
135 | goto err; | |
136 | } | |
137 | ||
85d6509d | 138 | host->hw_name = dev_name(&pdev->dev); |
a7626b7a AV |
139 | if (pdata && pdata->ops) |
140 | host->ops = pdata->ops; | |
141 | else | |
142 | host->ops = &sdhci_pltfm_ops; | |
ad82ab65 | 143 | if (pdata) { |
a7626b7a | 144 | host->quirks = pdata->quirks; |
ad82ab65 AC |
145 | host->quirks2 = pdata->quirks2; |
146 | } | |
147 | ||
a3456a2d | 148 | host->irq = platform_get_irq(pdev, 0); |
0a782cb1 MY |
149 | if (host->irq < 0) { |
150 | dev_err(&pdev->dev, "failed to get IRQ number\n"); | |
151 | ret = host->irq; | |
152 | goto err_request; | |
153 | } | |
a3456a2d | 154 | |
e95f644d MY |
155 | if (!devm_request_mem_region(&pdev->dev, iomem->start, |
156 | resource_size(iomem), | |
157 | mmc_hostname(host->mmc))) { | |
a3456a2d RR |
158 | dev_err(&pdev->dev, "cannot request region\n"); |
159 | ret = -EBUSY; | |
160 | goto err_request; | |
161 | } | |
162 | ||
163 | host->ioaddr = ioremap(iomem->start, resource_size(iomem)); | |
164 | if (!host->ioaddr) { | |
165 | dev_err(&pdev->dev, "failed to remap registers\n"); | |
166 | ret = -ENOMEM; | |
e95f644d | 167 | goto err_request; |
a3456a2d RR |
168 | } |
169 | ||
63ef5d8c JH |
170 | /* |
171 | * Some platforms need to probe the controller to be able to | |
172 | * determine which caps should be used. | |
173 | */ | |
174 | if (host->ops && host->ops->platform_init) | |
175 | host->ops->platform_init(host); | |
176 | ||
a3456a2d RR |
177 | platform_set_drvdata(pdev, host); |
178 | ||
85d6509d | 179 | return host; |
a3456a2d | 180 | |
a3456a2d RR |
181 | err_request: |
182 | sdhci_free_host(host); | |
183 | err: | |
85d6509d SG |
184 | dev_err(&pdev->dev, "%s failed %d\n", __func__, ret); |
185 | return ERR_PTR(ret); | |
a3456a2d | 186 | } |
f0de8369 | 187 | EXPORT_SYMBOL_GPL(sdhci_pltfm_init); |
a3456a2d | 188 | |
85d6509d | 189 | void sdhci_pltfm_free(struct platform_device *pdev) |
a3456a2d RR |
190 | { |
191 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
a3456a2d | 192 | |
a3456a2d | 193 | iounmap(host->ioaddr); |
a3456a2d | 194 | sdhci_free_host(host); |
85d6509d | 195 | } |
f0de8369 | 196 | EXPORT_SYMBOL_GPL(sdhci_pltfm_free); |
a3456a2d | 197 | |
85d6509d | 198 | int sdhci_pltfm_register(struct platform_device *pdev, |
0e748234 CD |
199 | const struct sdhci_pltfm_data *pdata, |
200 | size_t priv_size) | |
85d6509d SG |
201 | { |
202 | struct sdhci_host *host; | |
203 | int ret = 0; | |
204 | ||
0e748234 | 205 | host = sdhci_pltfm_init(pdev, pdata, priv_size); |
85d6509d SG |
206 | if (IS_ERR(host)) |
207 | return PTR_ERR(host); | |
208 | ||
38576af1 SG |
209 | sdhci_get_of_property(pdev); |
210 | ||
85d6509d SG |
211 | ret = sdhci_add_host(host); |
212 | if (ret) | |
213 | sdhci_pltfm_free(pdev); | |
214 | ||
215 | return ret; | |
a3456a2d | 216 | } |
f0de8369 | 217 | EXPORT_SYMBOL_GPL(sdhci_pltfm_register); |
a3456a2d | 218 | |
85d6509d SG |
219 | int sdhci_pltfm_unregister(struct platform_device *pdev) |
220 | { | |
221 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
83eacdfa | 222 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); |
85d6509d SG |
223 | int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff); |
224 | ||
225 | sdhci_remove_host(host, dead); | |
83eacdfa | 226 | clk_disable_unprepare(pltfm_host->clk); |
85d6509d SG |
227 | sdhci_pltfm_free(pdev); |
228 | ||
229 | return 0; | |
230 | } | |
f0de8369 | 231 | EXPORT_SYMBOL_GPL(sdhci_pltfm_unregister); |
515033f9 | 232 | |
be8ae09d | 233 | #ifdef CONFIG_PM |
d433dc63 | 234 | int sdhci_pltfm_suspend(struct device *dev) |
be8ae09d | 235 | { |
29495aa0 | 236 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d | 237 | |
29495aa0 | 238 | return sdhci_suspend_host(host); |
be8ae09d | 239 | } |
d433dc63 | 240 | EXPORT_SYMBOL_GPL(sdhci_pltfm_suspend); |
be8ae09d | 241 | |
d433dc63 | 242 | int sdhci_pltfm_resume(struct device *dev) |
be8ae09d | 243 | { |
29495aa0 | 244 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d GC |
245 | |
246 | return sdhci_resume_host(host); | |
247 | } | |
d433dc63 | 248 | EXPORT_SYMBOL_GPL(sdhci_pltfm_resume); |
29495aa0 ML |
249 | |
250 | const struct dev_pm_ops sdhci_pltfm_pmops = { | |
251 | .suspend = sdhci_pltfm_suspend, | |
252 | .resume = sdhci_pltfm_resume, | |
253 | }; | |
254 | EXPORT_SYMBOL_GPL(sdhci_pltfm_pmops); | |
be8ae09d | 255 | #endif /* CONFIG_PM */ |
f0de8369 SG |
256 | |
257 | static int __init sdhci_pltfm_drv_init(void) | |
258 | { | |
259 | pr_info("sdhci-pltfm: SDHCI platform and OF driver helper\n"); | |
260 | ||
261 | return 0; | |
262 | } | |
263 | module_init(sdhci_pltfm_drv_init); | |
264 | ||
265 | static void __exit sdhci_pltfm_drv_exit(void) | |
266 | { | |
267 | } | |
268 | module_exit(sdhci_pltfm_drv_exit); | |
269 | ||
270 | MODULE_DESCRIPTION("SDHCI platform and OF driver helper"); | |
271 | MODULE_AUTHOR("Intel Corporation"); | |
272 | MODULE_LICENSE("GPL v2"); |