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; | |
378382b8 | 122 | void __iomem *ioaddr; |
5c59065b | 123 | int irq, ret; |
a3456a2d | 124 | |
a3456a2d | 125 | iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
378382b8 MY |
126 | ioaddr = devm_ioremap_resource(&pdev->dev, iomem); |
127 | if (IS_ERR(ioaddr)) { | |
128 | ret = PTR_ERR(ioaddr); | |
a3456a2d RR |
129 | goto err; |
130 | } | |
131 | ||
5c59065b MY |
132 | irq = platform_get_irq(pdev, 0); |
133 | if (irq < 0) { | |
134 | dev_err(&pdev->dev, "failed to get IRQ number\n"); | |
135 | ret = irq; | |
136 | goto err; | |
137 | } | |
138 | ||
45c19e2a PM |
139 | host = sdhci_alloc_host(&pdev->dev, |
140 | sizeof(struct sdhci_pltfm_host) + priv_size); | |
a3456a2d RR |
141 | |
142 | if (IS_ERR(host)) { | |
143 | ret = PTR_ERR(host); | |
144 | goto err; | |
145 | } | |
146 | ||
378382b8 | 147 | host->ioaddr = ioaddr; |
5c59065b | 148 | host->irq = irq; |
85d6509d | 149 | host->hw_name = dev_name(&pdev->dev); |
a7626b7a AV |
150 | if (pdata && pdata->ops) |
151 | host->ops = pdata->ops; | |
152 | else | |
153 | host->ops = &sdhci_pltfm_ops; | |
ad82ab65 | 154 | if (pdata) { |
a7626b7a | 155 | host->quirks = pdata->quirks; |
ad82ab65 AC |
156 | host->quirks2 = pdata->quirks2; |
157 | } | |
158 | ||
63ef5d8c JH |
159 | /* |
160 | * Some platforms need to probe the controller to be able to | |
161 | * determine which caps should be used. | |
162 | */ | |
163 | if (host->ops && host->ops->platform_init) | |
164 | host->ops->platform_init(host); | |
165 | ||
a3456a2d RR |
166 | platform_set_drvdata(pdev, host); |
167 | ||
85d6509d | 168 | return host; |
a3456a2d | 169 | err: |
85d6509d SG |
170 | dev_err(&pdev->dev, "%s failed %d\n", __func__, ret); |
171 | return ERR_PTR(ret); | |
a3456a2d | 172 | } |
f0de8369 | 173 | EXPORT_SYMBOL_GPL(sdhci_pltfm_init); |
a3456a2d | 174 | |
85d6509d | 175 | void sdhci_pltfm_free(struct platform_device *pdev) |
a3456a2d RR |
176 | { |
177 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
a3456a2d | 178 | |
a3456a2d | 179 | sdhci_free_host(host); |
85d6509d | 180 | } |
f0de8369 | 181 | EXPORT_SYMBOL_GPL(sdhci_pltfm_free); |
a3456a2d | 182 | |
85d6509d | 183 | int sdhci_pltfm_register(struct platform_device *pdev, |
0e748234 CD |
184 | const struct sdhci_pltfm_data *pdata, |
185 | size_t priv_size) | |
85d6509d SG |
186 | { |
187 | struct sdhci_host *host; | |
188 | int ret = 0; | |
189 | ||
0e748234 | 190 | host = sdhci_pltfm_init(pdev, pdata, priv_size); |
85d6509d SG |
191 | if (IS_ERR(host)) |
192 | return PTR_ERR(host); | |
193 | ||
38576af1 SG |
194 | sdhci_get_of_property(pdev); |
195 | ||
85d6509d SG |
196 | ret = sdhci_add_host(host); |
197 | if (ret) | |
198 | sdhci_pltfm_free(pdev); | |
199 | ||
200 | return ret; | |
a3456a2d | 201 | } |
f0de8369 | 202 | EXPORT_SYMBOL_GPL(sdhci_pltfm_register); |
a3456a2d | 203 | |
85d6509d SG |
204 | int sdhci_pltfm_unregister(struct platform_device *pdev) |
205 | { | |
206 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
83eacdfa | 207 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); |
85d6509d SG |
208 | int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff); |
209 | ||
210 | sdhci_remove_host(host, dead); | |
83eacdfa | 211 | clk_disable_unprepare(pltfm_host->clk); |
85d6509d SG |
212 | sdhci_pltfm_free(pdev); |
213 | ||
214 | return 0; | |
215 | } | |
f0de8369 | 216 | EXPORT_SYMBOL_GPL(sdhci_pltfm_unregister); |
515033f9 | 217 | |
be8ae09d | 218 | #ifdef CONFIG_PM |
d433dc63 | 219 | int sdhci_pltfm_suspend(struct device *dev) |
be8ae09d | 220 | { |
29495aa0 | 221 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d | 222 | |
29495aa0 | 223 | return sdhci_suspend_host(host); |
be8ae09d | 224 | } |
d433dc63 | 225 | EXPORT_SYMBOL_GPL(sdhci_pltfm_suspend); |
be8ae09d | 226 | |
d433dc63 | 227 | int sdhci_pltfm_resume(struct device *dev) |
be8ae09d | 228 | { |
29495aa0 | 229 | struct sdhci_host *host = dev_get_drvdata(dev); |
be8ae09d GC |
230 | |
231 | return sdhci_resume_host(host); | |
232 | } | |
d433dc63 | 233 | EXPORT_SYMBOL_GPL(sdhci_pltfm_resume); |
29495aa0 ML |
234 | |
235 | const struct dev_pm_ops sdhci_pltfm_pmops = { | |
236 | .suspend = sdhci_pltfm_suspend, | |
237 | .resume = sdhci_pltfm_resume, | |
238 | }; | |
239 | EXPORT_SYMBOL_GPL(sdhci_pltfm_pmops); | |
be8ae09d | 240 | #endif /* CONFIG_PM */ |
f0de8369 SG |
241 | |
242 | static int __init sdhci_pltfm_drv_init(void) | |
243 | { | |
244 | pr_info("sdhci-pltfm: SDHCI platform and OF driver helper\n"); | |
245 | ||
246 | return 0; | |
247 | } | |
248 | module_init(sdhci_pltfm_drv_init); | |
249 | ||
250 | static void __exit sdhci_pltfm_drv_exit(void) | |
251 | { | |
252 | } | |
253 | module_exit(sdhci_pltfm_drv_exit); | |
254 | ||
255 | MODULE_DESCRIPTION("SDHCI platform and OF driver helper"); | |
256 | MODULE_AUTHOR("Intel Corporation"); | |
257 | MODULE_LICENSE("GPL v2"); |