]>
Commit | Line | Data |
---|---|---|
82c29810 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
a3456a2d RR |
2 | /* |
3 | * sdhci-pltfm.c Support for SDHCI platform devices | |
4 | * Copyright (c) 2009 Intel Corporation | |
5 | * | |
81e49922 | 6 | * Copyright (c) 2007, 2011 Freescale Semiconductor, Inc. |
38576af1 SG |
7 | * Copyright (c) 2009 MontaVista Software, Inc. |
8 | * | |
9 | * Authors: Xiaobo Xie <X.Xie@freescale.com> | |
10 | * Anton Vorontsov <avorontsov@ru.mvista.com> | |
a3456a2d RR |
11 | */ |
12 | ||
13 | /* Supports: | |
14 | * SDHCI platform devices | |
15 | * | |
16 | * Inspired by sdhci-pci.c, by Pierre Ossman | |
17 | */ | |
18 | ||
85d6509d | 19 | #include <linux/err.h> |
88b47679 | 20 | #include <linux/module.h> |
8199d312 | 21 | #include <linux/property.h> |
38576af1 SG |
22 | #include <linux/of.h> |
23 | #ifdef CONFIG_PPC | |
24 | #include <asm/machdep.h> | |
25 | #endif | |
515033f9 | 26 | #include "sdhci-pltfm.h" |
a3456a2d | 27 | |
d005d943 LPC |
28 | unsigned int sdhci_pltfm_clk_get_max_clock(struct sdhci_host *host) |
29 | { | |
30 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | |
31 | ||
32 | return clk_get_rate(pltfm_host->clk); | |
33 | } | |
34 | EXPORT_SYMBOL_GPL(sdhci_pltfm_clk_get_max_clock); | |
35 | ||
c915568d | 36 | static const struct sdhci_ops sdhci_pltfm_ops = { |
1771059c | 37 | .set_clock = sdhci_set_clock, |
2317f56c | 38 | .set_bus_width = sdhci_set_bus_width, |
03231f9b | 39 | .reset = sdhci_reset, |
96d7b78c | 40 | .set_uhs_signaling = sdhci_set_uhs_signaling, |
a3456a2d RR |
41 | }; |
42 | ||
8199d312 | 43 | static bool sdhci_wp_inverted(struct device *dev) |
38576af1 | 44 | { |
8199d312 AH |
45 | if (device_property_present(dev, "sdhci,wp-inverted") || |
46 | device_property_present(dev, "wp-inverted")) | |
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 | ||
8199d312 AH |
57 | #ifdef CONFIG_OF |
58 | static void sdhci_get_compatibility(struct platform_device *pdev) | |
38576af1 | 59 | { |
8199d312 | 60 | struct sdhci_host *host = platform_get_drvdata(pdev); |
38576af1 | 61 | struct device_node *np = pdev->dev.of_node; |
8199d312 AH |
62 | |
63 | if (!np) | |
64 | return; | |
65 | ||
66 | if (of_device_is_compatible(np, "fsl,p2020-rev1-esdhc")) | |
67 | host->quirks |= SDHCI_QUIRK_BROKEN_DMA; | |
68 | ||
69 | if (of_device_is_compatible(np, "fsl,p2020-esdhc") || | |
70 | of_device_is_compatible(np, "fsl,p1010-esdhc") || | |
71 | of_device_is_compatible(np, "fsl,t4240-esdhc") || | |
72 | of_device_is_compatible(np, "fsl,mpc8536-esdhc")) | |
73 | host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL; | |
74 | } | |
75 | #else | |
76 | void sdhci_get_compatibility(struct platform_device *pdev) {} | |
77 | #endif /* CONFIG_OF */ | |
78 | ||
79 | void sdhci_get_property(struct platform_device *pdev) | |
80 | { | |
81 | struct device *dev = &pdev->dev; | |
38576af1 SG |
82 | struct sdhci_host *host = platform_get_drvdata(pdev); |
83 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | |
7f217794 | 84 | u32 bus_width; |
38576af1 | 85 | |
8199d312 | 86 | if (device_property_present(dev, "sdhci,auto-cmd12")) |
5ec35820 | 87 | host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; |
38576af1 | 88 | |
8199d312 AH |
89 | if (device_property_present(dev, "sdhci,1-bit-only") || |
90 | (device_property_read_u32(dev, "bus-width", &bus_width) == 0 && | |
5ec35820 KH |
91 | bus_width == 1)) |
92 | host->quirks |= SDHCI_QUIRK_FORCE_1_BIT_DATA; | |
38576af1 | 93 | |
8199d312 | 94 | if (sdhci_wp_inverted(dev)) |
5ec35820 | 95 | host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT; |
38576af1 | 96 | |
8199d312 | 97 | if (device_property_present(dev, "broken-cd")) |
5ec35820 | 98 | host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; |
38ca7248 | 99 | |
8199d312 | 100 | if (device_property_present(dev, "no-1-8-v")) |
5ec35820 | 101 | host->quirks2 |= SDHCI_QUIRK2_NO_1_8_V; |
8ed765aa | 102 | |
8199d312 | 103 | sdhci_get_compatibility(pdev); |
147c3b33 | 104 | |
8199d312 | 105 | device_property_read_u32(dev, "clock-frequency", &pltfm_host->clock); |
f5ccfd41 | 106 | |
8199d312 | 107 | if (device_property_present(dev, "keep-power-in-suspend")) |
5ec35820 | 108 | host->mmc->pm_caps |= MMC_PM_KEEP_POWER; |
f5ccfd41 | 109 | |
8199d312 AH |
110 | if (device_property_read_bool(dev, "wakeup-source") || |
111 | device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */ | |
5ec35820 | 112 | host->mmc->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; |
38576af1 | 113 | } |
8199d312 | 114 | EXPORT_SYMBOL_GPL(sdhci_get_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 | ||
a3456a2d RR |
159 | platform_set_drvdata(pdev, host); |
160 | ||
85d6509d | 161 | return host; |
a3456a2d | 162 | err: |
85d6509d SG |
163 | dev_err(&pdev->dev, "%s failed %d\n", __func__, ret); |
164 | return ERR_PTR(ret); | |
a3456a2d | 165 | } |
f0de8369 | 166 | EXPORT_SYMBOL_GPL(sdhci_pltfm_init); |
a3456a2d | 167 | |
85d6509d | 168 | void sdhci_pltfm_free(struct platform_device *pdev) |
a3456a2d RR |
169 | { |
170 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
a3456a2d | 171 | |
a3456a2d | 172 | sdhci_free_host(host); |
85d6509d | 173 | } |
f0de8369 | 174 | EXPORT_SYMBOL_GPL(sdhci_pltfm_free); |
a3456a2d | 175 | |
85d6509d | 176 | int sdhci_pltfm_register(struct platform_device *pdev, |
0e748234 CD |
177 | const struct sdhci_pltfm_data *pdata, |
178 | size_t priv_size) | |
85d6509d SG |
179 | { |
180 | struct sdhci_host *host; | |
181 | int ret = 0; | |
182 | ||
0e748234 | 183 | host = sdhci_pltfm_init(pdev, pdata, priv_size); |
85d6509d SG |
184 | if (IS_ERR(host)) |
185 | return PTR_ERR(host); | |
186 | ||
8199d312 | 187 | sdhci_get_property(pdev); |
38576af1 | 188 | |
85d6509d SG |
189 | ret = sdhci_add_host(host); |
190 | if (ret) | |
191 | sdhci_pltfm_free(pdev); | |
192 | ||
193 | return ret; | |
a3456a2d | 194 | } |
f0de8369 | 195 | EXPORT_SYMBOL_GPL(sdhci_pltfm_register); |
a3456a2d | 196 | |
85d6509d SG |
197 | int sdhci_pltfm_unregister(struct platform_device *pdev) |
198 | { | |
199 | struct sdhci_host *host = platform_get_drvdata(pdev); | |
83eacdfa | 200 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); |
85d6509d SG |
201 | int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff); |
202 | ||
203 | sdhci_remove_host(host, dead); | |
83eacdfa | 204 | clk_disable_unprepare(pltfm_host->clk); |
85d6509d SG |
205 | sdhci_pltfm_free(pdev); |
206 | ||
207 | return 0; | |
208 | } | |
f0de8369 | 209 | EXPORT_SYMBOL_GPL(sdhci_pltfm_unregister); |
515033f9 | 210 | |
2b330999 | 211 | #ifdef CONFIG_PM_SLEEP |
83a7b32a | 212 | int sdhci_pltfm_suspend(struct device *dev) |
be8ae09d | 213 | { |
29495aa0 | 214 | struct sdhci_host *host = dev_get_drvdata(dev); |
1ab0d2d7 MY |
215 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); |
216 | int ret; | |
be8ae09d | 217 | |
d38dcad4 AH |
218 | if (host->tuning_mode != SDHCI_TUNING_MODE_3) |
219 | mmc_retune_needed(host->mmc); | |
220 | ||
1ab0d2d7 MY |
221 | ret = sdhci_suspend_host(host); |
222 | if (ret) | |
223 | return ret; | |
224 | ||
225 | clk_disable_unprepare(pltfm_host->clk); | |
226 | ||
227 | return 0; | |
be8ae09d | 228 | } |
83a7b32a | 229 | EXPORT_SYMBOL_GPL(sdhci_pltfm_suspend); |
be8ae09d | 230 | |
83a7b32a | 231 | int sdhci_pltfm_resume(struct device *dev) |
be8ae09d | 232 | { |
29495aa0 | 233 | struct sdhci_host *host = dev_get_drvdata(dev); |
1ab0d2d7 MY |
234 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); |
235 | int ret; | |
236 | ||
237 | ret = clk_prepare_enable(pltfm_host->clk); | |
238 | if (ret) | |
239 | return ret; | |
be8ae09d | 240 | |
1ab0d2d7 MY |
241 | ret = sdhci_resume_host(host); |
242 | if (ret) | |
243 | clk_disable_unprepare(pltfm_host->clk); | |
244 | ||
245 | return ret; | |
be8ae09d | 246 | } |
83a7b32a | 247 | EXPORT_SYMBOL_GPL(sdhci_pltfm_resume); |
2b330999 | 248 | #endif |
29495aa0 ML |
249 | |
250 | const struct dev_pm_ops sdhci_pltfm_pmops = { | |
2b330999 | 251 | SET_SYSTEM_SLEEP_PM_OPS(sdhci_pltfm_suspend, sdhci_pltfm_resume) |
29495aa0 ML |
252 | }; |
253 | EXPORT_SYMBOL_GPL(sdhci_pltfm_pmops); | |
f0de8369 SG |
254 | |
255 | static int __init sdhci_pltfm_drv_init(void) | |
256 | { | |
257 | pr_info("sdhci-pltfm: SDHCI platform and OF driver helper\n"); | |
258 | ||
259 | return 0; | |
260 | } | |
261 | module_init(sdhci_pltfm_drv_init); | |
262 | ||
263 | static void __exit sdhci_pltfm_drv_exit(void) | |
264 | { | |
265 | } | |
266 | module_exit(sdhci_pltfm_drv_exit); | |
267 | ||
268 | MODULE_DESCRIPTION("SDHCI platform and OF driver helper"); | |
269 | MODULE_AUTHOR("Intel Corporation"); | |
270 | MODULE_LICENSE("GPL v2"); |